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

The annotations already declare destructiveHint=true, so the description does not need to repeat that. It adds useful context by referencing the OSC selection and the /eos/at command path, but it does not describe side effects beyond setting the level or explain what destructive consequences might occur.

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

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

The description is a single sentence that conveys the core action, target, and mechanism with no filler. Every part contributes meaning, 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 and mostly explained by the description plus schema. However, the optional 'confirm' parameter is not elaborated, and there is no explanation of what happens when it is used. Given no output schema and sparse behavioral detail, the description is adequate but leaves some gaps.

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

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

Schema description coverage is 0%, so the description should compensate for the parameter schema. It only implies the 'level' parameter via the tool name and description, and it provides no semantic information about the optional 'confirm' parameter. The schema provides value ranges, but the description adds little meaning beyond that.

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

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

The description identifies a specific action ('Set level'), a specific resource ('current OSC selection'), and the mechanism ('via /eos/at'). It clearly differentiates this tool from sibling tools like submaster_set_level, group_set_level, and channel_set_level by scoping it to the current OSC selection.

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 'current OSC selection' provides clear context for when this tool is appropriate: when the user wants to set the level of whatever is currently selected via OSC. It does not explicitly name alternatives or exclusions, but the context is unambiguous enough to guide selection among the sibling tools.

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

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

No annotations are provided, so the description bears full responsibility for disclosing behavioral traits. It does mention 'leaves command line unterminated,' which is a key behavioral note, but it leaves significant gaps: it doesn't state whether selection is temporary or persistent, whether it overwrites any current selection, whether the command line is cleared or appended, or what side effects occur. For a tool that modifies console state, this is incomplete. The description gives some insight but not enough for an agent to predict the full impact.

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

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

The description is a single, concise sentence with no filler. It states the action and a critical behavioral note in a compact way. This is efficient and front-loaded with the most important information. It earns a high score for brevity and clarity.

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

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

Given that this is a simple tool with one required parameter and no output schema, the description is expected to be brief. However, it lacks critical context such as the format of the channel value (e.g., integer only? ranges?), and the implications of the command line being unterminated (e.g., does the agent need to then send another command? Is the command line pending?). With no annotation safety hints and no parameter semantics, an agent is left guessing about side effects. The description is too sparse to be fully usable 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 description coverage is 0%, meaning the schema only provides the type (integer) and bounds. The description does not explain what 'channel' refers to (e.g., channel number, range, or syntax) or how it should be formatted. Since there is no extra context, the parameter's meaning is entirely undefined. The description adds zero value beyond the schema's bare type definition, which is insufficient for an agent to know how to set the value correctly.

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

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

The description clearly states the verb (Select), the resource (an Eos channel), and an important behavior ('leaves command line unterminated'). This is a specific and meaningful definition that distinguishes it from other sibling tools like channel_set_level or channel_set_dmx, which would not leave the command line open. The purpose is unambiguous.

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

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

The description implicitly indicates that this tool is for selecting a channel in preparation for further commands (since it leaves the command line unterminated). However, it doesn't explicitly state when to use this versus channel_set_level, channel_set_dmx, or cue_select. It lacks a clear 'use this if you need to start a command line' directive and doesn't mention alternatives. The behavior of leaving the command line open is a hint, but not explicit guidance.

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

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

The annotation destructiveHint: true already signals the operation is destructive, so the description doesn't need to repeat that. However, the description adds no further behavioral context, such as whether the change is reversible, affects live output, or requires the optional confirm parameter. It is minimal but not contradictory.

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

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

The description is a single, short sentence that is front-loaded with the core action and resource. There is no wasted wording, making it highly concise and easy to parse quickly.

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

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

For a tool with 3 parameters (one optional), no output schema, and a rich set of sibling tools, the description is too sparse. It omits the purpose of the optional confirm parameter, does not mention any side effects or return behavior, and fails to help an agent decide when to use this over similar tools.

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

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

With schema description coverage at 0%, the description must compensate for parameter explanations, but it only mentions the dmx range (0-255), which is already in the schema's min/max. It does not clarify the meaning of 'channel' or the optional 'confirm' flag, leaving these parameters under-explained.

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 ('Set') and the resource ('a channel DMX level') with a range. It distinguishes itself from sibling tools like submaster_set_level or group_set_level by specifying 'channel DMX level'. However, it doesn't explicitly contrast with channel_set_level, leaving some ambiguity about the precise difference.

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. There is no mention of scenarios where direct DMX setting is preferred over channel_set_level or at_set_level, nor any prerequisites or context for invocation.

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 declare destructiveHint=true, so the mutation is already flagged, but the description adds no behavioral context beyond that. It does not mention the optional confirm parameter, what setting intensity affects, or any side effects.

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

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

The description is a single, front-loaded sentence with no filler words. It is concise and scannable, though it is so brief that it sacrifices useful detail that other dimensions require.

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 setter with three parameters and no parameter descriptions, the description is incomplete. It does not explain the confirm parameter, differentiate from closely related set-level tools, or describe expected behavior or return value, leaving the agent to guess in contexts where several similar tools 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?

Schema description coverage is 0%, so the description must compensate for parameter meaning. It adds 'intensity' as semantic context for the level parameter, which is useful, but it says nothing about the channel parameter or the optional confirm parameter, leaving significant 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 clearly identifies the action ('Set') and the resource ('a channel intensity'), and the (0-100) range adds specificity. It distinguishes itself from channel_set_dmx by using 'intensity', but it does not explicitly name or contrast sibling tools such as group_set_level or submaster_set_level.

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

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

There is no guidance on when to use this tool versus alternatives like channel_set_dmx or group_set_level. The tool name and description imply its purpose, but no explicit context, exclusions, or alternative recommendations are provided.

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

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

Annotations already mark this as destructive, and the description adds the GO sequencing caveat as behavioral context. It does not explain the destructive side effects, the role of confirm, or what happens after firing, but it also does not contradict the destructiveHint annotation.

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

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

The description is one concise sentence with no filler. It front-loads the action and includes the most important behavioral caveat in a compact parenthetical. Missing detail is a completeness issue, not a conciseness issue.

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 tool with three parameters, no parameter descriptions, no output schema, and no explicit usage guidance, this description leaves major gaps. An agent cannot confidently determine how confirm or cueList affect the call or what the side effects of firing a cue are.

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 0%, so the description needs to compensate. It only implies that 'cue' identifies the cue to fire, leaving the confirm boolean and cueList integer entirely unexplained. This is insufficient for reliable invocation.

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

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

The description uses the specific verb 'fire' on the resource 'cue' and explicitly distinguishes this tool from sibling cue_go by noting it does not follow GO sequencing unless cue_go is used. This makes the primary action and scope immediately clear.

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

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

The parenthetical 'does not follow GO sequencing unless using cue_go' signals a meaningful difference from a sibling tool and implies when cue_go would be the appropriate choice. However, it stops short of giving explicit when-to-use/when-not-to-use instructions.

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 annotation already labels the operation as destructive, and the description adds that the action advances cues sequentially. However, it does not explain what the destructive effect is (e.g., changing the current cue), whether confirmation is involved, or any reversible details.

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

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

The description is a single, tightly written sentence with no filler. The key action and outcome are front-loaded, though it is sparse enough that some necessary details are omitted.

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 marked destructive with an undocumented confirm parameter and no output schema, this description is too thin. It fails to mention the confirm parameter's purpose or to provide any comparison with sibling cue tools, so an agent may not know how to call it safely or choose it correctly.

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

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

The input schema contains one optional boolean, 'confirm', with 0% description coverage. The tool description does not mention this parameter or explain when/why to set it, leaving the agent to guess whether confirmation is required or what it guards against.

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 ('Press the console Go key') and a concrete resource (the console Go key), then clarifies the effect as 'sequential cue advance.' This differentiates it from siblings like cue_fire or cue_select, which target specific cues rather than advancing the sequence.

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 'sequential cue advance' implies when the tool is appropriate, but the description does not explicitly say when to use this over cue_fire, cue_select, or other cue-related siblings. There are no stated exclusions or alternative 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states the action 'select a cue' without addressing whether this changes the console's active cue, whether it is reversible, or any side effects. The term 'select' implies a state change but no details are given, leaving the agent in the dark about consequences.

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 is appropriately concise for a simple tool, though the extreme brevity means it sacrifices content for length. It is not a tautology and reads naturally, so conciseness is good, but it leaves the reader wanting more 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?

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is incomplete. It fails to explain what 'selecting' accomplishes, any required context (e.g., must a cue list be specified?), or what the return value is. Sibling tools like channel_select might provide analogous behavior, but this description alone does not give the agent enough to understand the tool's full impact or prerequisites.

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 0%, so the description must add meaning to the parameters. It does mention that the cue can be 'optionally within a cue list', which clarifies the cueList parameter's role and optionality. However, it does not explain the 'cue' parameter's format or semantics beyond being a cue identifier, nor does it describe the relationship between cue and cueList. The provided hint is useful but minimal, barely compensating for the lack of schema descriptions.

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

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

The description states a clear action (select) on a resource (cue), with an optional modifier (within a cue list). It distinguishes from sibling tools like cue_fire and cue_go, which imply execution rather than selection, so the agent can infer the difference. However, it does not specify what 'select' means (e.g., sets the active cue, for editing, etc.), leaving some ambiguity about the tool's effect.

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

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

The description provides no guidance on when to use this tool versus alternatives. Siblings like cue_fire and cue_go clearly relate to running cues, but the description does not explicitly state that cue_select is for setting/choosing a cue rather than firing it, nor does it mention any prerequisites or contexts. This is left wholly to inference.

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

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

The annotations already provide destructiveHint=true, and the description adds that this sends commands via OSC and is intended for mutating operations like record, patch, copy, and save. It does not elaborate on side effects, reversibility, or confirmation behavior beyond what the schema already documents for the confirm parameter. No contradiction exists.

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

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

The description is two compact sentences with no filler. It front-loads the action and transport, then immediately states practical use cases. Every sentence earns its place.

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

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

For a tool with fully documented parameters and a destructive annotation, the description is largely complete: it names the mechanism, the scope, and common operations. It does not describe return behavior or error handling, but there is no output schema and the intended selection context is sufficiently clear.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters. The description does not add parameter-specific details, but it does reinforce that the text parameter is an Eos command-line instruction. This is the baseline 3 case where the schema carries the semantic weight.

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 specific action ('Send an Eos command-line instruction') and the transport mechanism ('via OSC (/eos/cmd)'), and gives concrete use cases: record, patch, copy, save, and CLI-only operations. It is not a tautology and is clearly distinct from high-level sibling tools, though it does not explicitly differentiate itself from similarly named eos_new_command.

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

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

The description provides clear selection context: 'Use for record, patch, copy, save, and any CLI-only operations.' This helps an agent decide when to invoke this tool. However, it does not explicitly state when not to use it or name alternative sibling tools, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and syntax reference, but fails to reveal any behavioral traits: whether the event causes side effects, requires confirmation, how the terminator affects execution, or what the response looks like. The reference to eos_command is not descriptive of this tool's own behavior.

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

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

The description is a single sentence with no wasted words, which earns points for brevity. However, it lacks any structure beyond the bare statement, and it is so sparse that it fails to convey essential context. The brevity is not balanced with adequate clarity.

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

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

Given the tool has 3 parameters, no schema descriptions, no annotations, and no output schema, the description is severely incomplete. It provides no information about parameter semantics, use cases, or expected behavior, leaving an agent unable to construct a valid invocation confidently. The only hint is the reference to eos_command, which is not elaborated.

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

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

The schema has 3 parameters (text, confirm, terminator) with zero description coverage, and the description does not mention any of them. The phrase 'same syntax as eos_command' does not explain what each parameter means or how they relate. An agent cannot infer the purpose of 'confirm' or the terminator enum values from this description.

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

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

The description clearly states the action ('Send a console event') and the resource (the /eos/event endpoint). It references eos_command for syntax, which gives a hint of its scope. However, it does not explicitly differentiate from the sibling eos_command, so the purpose is clear but not well-distinguished.

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 only says 'same syntax as eos_command' but offers no guidance on when to use this tool versus eos_command or other siblings like key_press. There is no mention of use cases, exclusions, or conditions that would select this tool over alternatives.

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

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

The destructiveHint annotation is true, so the destructive nature is already signaled. The description adds the specific action of clearing the command line, which is consistent, but does not disclose other behavioral traits like whether confirmation is required or what happens on failure. With annotations covering the primary risk, this is a 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?

The description is one concise sentence with no filler, front-loading the primary action. It is efficient and easy to parse, though it could be slightly more informative without harming 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 tool with three parameters, no output schema, and a destructive note, the description is severely incomplete. It omits parameter meanings, usage context, return behavior, and any caveats, leaving an agent with insufficient information 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 0%, and the description offers no explanation of text, confirm, or terminator parameters. The phrase 'send an instruction' vaguely references the text parameter but fails to clarify formats or semantics, providing no compensation for the schema gap.

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

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

Description states a clear action: clear the command line then send an instruction via /eos/newcmd, giving a specific verb and resource. However, it doesn't differentiate from sibling eos_command or explain when this variant is preferred, so it lacks sibling distinction.

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

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

No guidance on when to use this tool versus alternatives like eos_command. The description implies a clear-before-send workflow, but there's no explicit context, prerequisites, or exclusions, leaving usage to inference.

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

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

The read-only behavior is already disclosed by the readOnlyHint annotation, and the description accurately reflects a read operation. It adds the context that data comes from OSC cache, which is useful, but it does not describe behaviors like cache miss handling or whether the active cue is explicit or selected.

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

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

The description is a single, clear sentence that front-loads the action and returns key information. No words are wasted and the structure is immediately readable.

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, parameterless tool, the description covers the core purpose and output. It does not promise an output schema or detail edge cases, but given the low complexity and safe annotation, the definition is sufficiently complete.

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

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

The tool has zero parameters, so the description does not need to add parameter-level detail. The schema covers everything needed for invocation, satisfying the baseline for a no-parameter tool.

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

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

The description uses a specific verb ('Return') and resource ('active cue text and completion percent'), and specifies the source ('OSC cache'). This clearly distinguishes it from sibling tools like cue_select or get_console_state, which focus on different actions or 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?

No guidance is provided about when to call this tool versus siblings such as cue_go, cue_select, or get_console_state. The intended context is only implied by the name and description, not explicitly 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 annotation readOnlyHint=true already discloses that this is a read-only operation. The description adds the useful behavioral detail that the value comes from the OSC cache, implying it reflects cached rather than live statetools. However, it does not describe output formatting, cache freshness, or what happens when no command line is present.

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

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

The description is one concise sentence with no filler. It front-loads the action and resource and immediately states the data source.

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 provides the essential return content and source. It is slightly light on behavioral context such as cache dynamics or expected format, but given the tool's simplicity, it is substantially complete.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there are no parameter semantics to clarify. The description accurately identifies the single return source, which is all an agent needs to know.

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

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

The description states a specific action ('Return') and resource ('current command line text') with the source ('OSC cache'). This clearly distinguishes it from sibling tools like eos_command or cue_go, which represent different operations.

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

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

The description gives no guidance on when to use this tool versus alternatives. While the name and description imply a read-only retrieval of command-line text, there is no explicit context, exclusion, or mention of when another sibling 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.

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

The readOnlyHint annotation already signals this is a non-mutating operation. The description adds useful behavioral context by noting the state is cached and by listing the returned dimensions, but it does not disclose details like staleness semantics or whether any connection-specific setup is required. This is adequate but not rich.

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

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

The description is one short, front-loaded sentence that names the action, the resource, and the key return components. Every word earns its place, and there is no redundant 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 tool, the description provides enough context to know what data will be returned and that it is cached. It is slightly light on the exact shape or formatting of the user/connection values, but the absence of an output schema and the tool's simplicity make this a minor gap rather than a blocking one.

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

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

The tool has zero parameters and the schema coverage is effectively total, so there is no parameter meaning for the description to add. Per the rubric, a no-parameter tool starts at baseline 4; the description correctly avoids inventing 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 ('Return') and resource ('cached console state'), then enumerates exactly what state is included: blind/live, user, and connection. This clearly distinguishes it from sibling tools like cue_fire or channel_set_level, none of which return console 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?

The description implies that the tool is used when an agent needs the current cached console state, and the sibling names make it clear that most other tools perform actions rather than reads. However, it does not explicitly state when to prefer this tool over alternatives such as get_active_cue or get_command_line, nor does it provide exclusions.

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

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

The annotation destructiveHint: true indicates that the tool may have destructive effects, but the description does not elaborate on what those might be or how to mitigate them. There is no mention of the confirm parameter, which likely serves as a safety check. The tool changes settings, which might overwrite existing intensity values, but the description doesn't clarify reversibility or side effects, leaving the agent to infer.

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

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

The description is a single sentence with no wasted words, efficient and to the point. It is appropriately sized for simple tools. It front-loads the main action ('Set a group intensity') and includes the range constraint, which is useful. However, it misses opportunity to add context but does not over-elaborate.

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

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

Given the tool's moderate complexity (3 parameters, destructiveHint), the description is incomplete. It lacks guidance on the 'group' identifier, the meaning of 'confirm' (likely to confirm a destructive change), and any behavioral consequences. There is no output schema, so the description should explain what the result is, but it doesn't. The missing parameter semantics and usage guidelines make it insufficient for an agent to use correctly without guesswork.

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 0%, meaning the schema provides no descriptions for parameters. The description does not elaborate on the 'group' parameter (e.g., how to identify a group) or the 'confirm' parameter (what it does, whether required for destructive operations). The 'level' parameter is somewhat clarified by the range in the schema, but the description adds no additional meaning. This is a significant gap given no schema descriptions.

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

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

The description states a specific verb 'Set' and resource 'group intensity', and includes the allowed range (0-100). It is clear that this tool modifies the intensity of a group. It does not explicitly distinguish from siblings like submaster_set_level or channel_set_level, but the resource type 'group' is distinct enough for basic 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?

The description does not provide any guidance on when to use this tool versus alternatives such as channel_set_level or submaster_set_level. Context signals show a sibling 'submaster_set_level' which could be confusing, but no exclusions or alternative references are given. The description only implies usage for setting group intensity, but without context on when a group is required over other entities.

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 indicate destructiveHint: true, and the description itself suggests a physical key press, but it does not elaborate on potential consequences (e.g., triggering actions with side effects). However, the description's simplicity combined with the annotation is adequate; it would benefit from noting that pressing a key may have irreversible effects.

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

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

The description is a single, short sentence with examples, front-loading the core purpose. It is efficient and contains 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 tool with three parameters and no output schema, the description covers the main action but leaves parameter details to the schema. It lacks guidance on the 'edge' and 'confirm' semantics and potential side effects, which is a gap for a tool with a destructive hint.

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 low (33%) – only 'key' is described. The description does not explain the 'edge' or 'confirm' parameters, but these are relatively self-explanatory given the enum and boolean type. The description adds minimal semantic value beyond the schema.

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

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

The description clearly states the action ('Press'), the resource ('Eos hardkey'), and the method ('by OSC name'), with concrete examples. It is distinguishable from siblings like 'cue_go' and 'macro_fire' because it targets hardkeys rather than cues or macros.

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 for pressing hardkeys, but does not specify when to prefer this over alternatives like 'eos_command' or when not to use it (e.g., for software keys vs hardkeys). No explicit exclusions are given.

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

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

The destructiveHint annotation already signals risk, and the description does not contradict it. However, the description adds no behavioral detail beyond 'run a macro'—it does not mention side effects, confirmation behavior, or what executing a macro can change on the console.

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

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

The description is one short, front-loaded sentence with no filler or redundant wording. It conveys the core operation immediately, which is ideal for a simple tool name.

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

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

For a destructive, side-effect-producing tool with no output schema and no parameter documentation, this bare sentence is insufficient. An agent can minimally construct a call using the schema, but it lacks the safety and confirmation semantics needed to use the tool confidently.

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

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

With 0% schema description coverage, the description needed to explain both parameters. It only clarifies that the macro is selected 'by number'; the optional 'confirm' parameter is completely undocumented, and no context is given about its effect on execution.

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

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

The description states a clear action ('Run') on a specific resource ('a macro') and the selection mechanism ('by number'). No sibling tool targets macros, so an agent can distinguish this from cue_fire, key_press, or other console 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 guidance about when to use this tool versus alternatives such as key_press, eos_command, or cue_fire. There are no exclusions, prerequisites, or context about macro execution being a different path from cue or channel operations.

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

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

No annotations are provided, so the description carries the full burden. It states the action but does not disclose side effects, permissions, whether it changes the current display, or what happens when called; this is a significant transparency gap for a command that alters console state.

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

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

A single front-loaded sentence that conveys the core purpose and the optional parameter without filler. Every word earns its place.

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

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

For a simple opening action with two integer parameters, the description covers the basic operation, but it lacks any context about output, result, error cases, or how an agent should resolve the magic-sheet/view IDs. With no output schema and no annotations, these gaps matter.

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

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

The schema provides no parameter descriptions (0% coverage), and the description at least connects 'sheet' to the magic sheet and 'view' to the specific view. It does not explain how IDs are obtained, what values are valid, or what happens if view is omitted beyond implying it is optional.

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 concrete action ('Open') and resource ('a magic sheet'), and adds the optional 'view' dimension. It is clear, though it does not explicitly contrast with sibling tools or explain how this differs from the other console commands.

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

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

The wording implies this tool is for displaying a magic sheet. The intended use is inferable, but the description gives no explicit guidance about when to use it versus alternatives or any prerequisites/constraints.

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

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

With no annotations, the description carries the burden of explaining behavior. It does disclose the underlying action ('Send /eos/reset') and its effect, which adds useful transparency. However, it omits side effects, whether confirmation is needed, or any state-change warnings beyond 'clear OSC switches.'

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

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

The description is one efficient sentence with the action front-loaded and the effect following. Every word adds value and there is no repetition or filler.

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

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

Although the tool is simple, the description fails to explain the confirm parameter and gives no usage context relative to sibling OSC/EOS tools. There is no output schema and no annotations, so the agent is left with an incomplete picture for a mutating operation.

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

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

Schema description coverage is 0%, so the description must explain the single 'confirm' boolean parameter, but it never mentions it. An agent cannot determine what confirm controls, its default behavior, or whether it affects the reset operation.

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 protocol command ('Send /eos/reset') and states the action's result ('clear OSC switches and refresh implicit output'), making the tool's function concrete. It does not explicitly contrast itself with generic siblings like eos_command, which prevents a 5.

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

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

No guidance is given on when to use this tool versus alternatives such as eos_command or macro_fire. The description implies when it might be appropriate but lacks explicit trigger conditions, exclusions, or comparisons.

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 does not add any behavioral context beyond the destructiveHint annotation. It does not explain what gets destroyed, whether a confirmation is required, or any side effects. The 'confirm' parameter is not mentioned, and the description does not elaborate on the mutation's impact.

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

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

The description is a single, concise sentence that front-loads the core action. It contains no fluff and efficiently communicates the primary purpose, which is appropriate for conciseness.

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

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

For a tool with three parameters and a destructive annotation, the description is insufficient. It does not explain the 'confirm' parameter, the meaning of 'sub', or any prerequisites or consequences. An agent would lack essential context to call this tool correctly and 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?

With 0% schema description coverage, the description must compensate but fails to do so. It mentions the 'level' range but does not explain what 'sub' refers to or the purpose of the 'confirm' parameter. An agent cannot infer the meaning or usage of these parameters from the text.

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 ('Set') and the target resource ('submaster level') with a specific range. It is distinct from sibling tools like channel_set_level or group_set_level because it explicitly targets the submaster, leaving no ambiguity about what the tool operates on.

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. It does not mention any conditions, exclusions, or context that would help an agent decide between this and other set-level tools. The only hint is the resource name itself, which is implicit at best.

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, covering safety. The description adds that the tool waits for a message and respects a timeout, which is meaningful behavior. However, it does not disclose what happens on timeout, whether the wait is blocking/cancellable, or whether receipt is acknowledged or just observed.

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

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

The description is one compact sentence with no filler. It front-loads the action and resource, and the parenthetical efficiently conveys the key timeout parameter. Every word earns its place.

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

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

Given the low schema coverage and absence of an output schema, the description is too lean to fully plan a call. It omits the meaning of useRegex, the timeout behavior on expiry, the return/result semantics, and any relationship to sibling OSC tools. An agent can guess the purpose but not the complete invocation contract.

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 only 33%, so the description must compensate for undocumented parameters. It clarifies that timeoutMs is in milliseconds and that address is a pattern, but it leaves useRegex entirely unexplained and gives no defaults or optionality semantics. This is insufficient for the undocumented parameters.

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

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

The description uses a specific verb ('Wait'), a precise resource ('incoming OSC address pattern'), and a timeout qualifier. It is clearly distinguishable from siblings like eos_command, key_press, and osc_reset, so an agent can tell what this tool is for without expanding the schema.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of related tools such as osc_reset or eos_event. The description simply states the operation, leaving the agent to infer appropriate call conditions.

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