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

With no annotations, the description carries the full burden, and it does disclose the core behavior: a timed transition of the background layer from Preview to Program using the current effect. However, it omits mutation-side details such as required permissions, whether the operation is interruptible/cancelable, timing/duration behavior, and what state results on the bus.

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 adds real clarifying value about the Preview-to-Program semantics rather than restating the name.

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

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

For a zero-parameter, no-output-schema action with no annotations, the description covers the observable effect but leaves out operational context an agent needs to invoke it correctly — notably the precondition of a set Preview source and configured transition effect, plus how it relates to cut_transition and set_transition_effect.

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; the baseline for a 0-parameter tool applies. The description appropriately focuses on behavior rather than nonexistent 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 ('Perform an Auto transition') and resource ('main switcher background layer'), and clarifies the domain meaning by explaining that it takes Preview to Program using the current effect. It is understandable without opening any schema, though it never names the sibling cut_transition or switch_program to explicitly differentiate the operation.

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

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

The description explains what an Auto transition is but gives no guidance on when to choose it over cut_transition, switch_program, or set_transition_effect, and states no prerequisites (e.g. that a Preview source must be set, or that a transition effect must be configured first). Usage must be inferred entirely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It conveys that this is a browsing (non-mutating) operation by implication, but says nothing about permissions, return format, pagination, or whether the media library is live/recording state — significant gaps for a zero-annotation tool.

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

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

Two short sentences, front-loaded with the core action before the optional parameter detail. Efficient, with only minor redundancy against the schema's own path description.

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 read tool this is roughly adequate, but with no output schema the description should hint at what browsing returns (file names, folders, metadata) rather than leaving result shape entirely unstated.

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 'path' parameter is already documented as optional with root fallback, so the description adds no semantic detail beyond what the schema states. 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+resource ('Browse available media files') scoped to the TriCaster, so an agent can distinguish it from sibling listing tools like list_sources or list_macros. It does not explicitly contrast itself with those siblings, which keeps it just 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 second sentence implies usage: call with no path for root, or supply a path for a specific folder. There is no explicit when-to-use/when-not guidance or reference to related media tools, so usage is only inferred.

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 does disclose the key behavior — an instantaneous swap of Program and Preview — but says nothing about permissions, reversibility, or the resulting switcher 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 tight sentence with the verb and the scope front-loaded; 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 zero-parameter, single-effect switcher action this is nearly sufficient; only the missing note on what happens after the cut (or its return value) keeps it short of 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 schema baseline of 4 applies; there is nothing 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 concrete verb ('Perform') and resource ('Cut transition'), and clarifies the effect as a Program ↔ Preview swap, which is more than a restatement of the name. It implicitly separates itself from auto_transition and set_transition_effect, though it never names 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 explicit when-to-use or when-not guidance is given; the agent must infer from 'instant' that this is the immediate alternative to auto_transition. With a sibling named auto_transition present, the absence of routing language is a real gap.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says playback starts but does not disclose side effects, required permissions, whether playback is exclusive, or what happens if the DDR is already playing.

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. It is appropriately sized for a simple one-parameter command, even if it is under-specified elsewhere.

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 play command with one documented enum parameter and no output schema, the description is minimally sufficient. It lacks behavioral context about playback state, but the schema and low complexity keep this from being inadequate.

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

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

Schema description coverage is 100%: the sole parameter 'ddr' is an enum documented as 'DDR number (1 or 2)'. The description adds no parameter meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description gives a clear verb ('Play') and resource ('DDR (media player)'), making the basic action understandable. It does not differentiate from siblings like ddr_stop or ddr_set_autoplay, 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?

There is no explicit guidance on when to use this tool versus alternatives such as ddr_stop or ddr_set_autoplay, nor any prerequisites or exclusions. Usage is only implied by the verb.

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 does not disclose whether the setting persists, whether it interrupts current playback, whether it requires the DDR to be idle, or what happens on failure.

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 action front-loaded and the DDR parenthetical earning its place by decoding the acronym. No padding, though there is little to structure.

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 toggle with no output schema the description is minimally adequate, but with no annotations it should at least note persistence or interaction with playback siblings. The essential call mechanics are covered by the schema, leaving only behavioral context 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?

Schema description coverage is 100%: both 'ddr' (enum 1 or 2) and 'enabled' (boolean) are documented in the schema. The description adds no format or meaning beyond that, so the baseline of 3 is appropriate.

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

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

States a specific verb (enable/disable) and resource (autoplay mode on a DDR), and clarifies the DDR acronym as a media player. However, it does nothing to distinguish this from siblings like ddr_play, ddr_stop, or ddr_set_loop, 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?

No when-to-use guidance is given beyond the obvious toggle semantics. It never explains how this relates to ddr_play/ddr_stop (does enabling autoplay start playback?) or when an agent would prefer this over those siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether enabling loop restarts playback, whether the setting persists across clips or reboots, whether it requires the DDR to be playing, or what errors occur if the DDR is idle — all material for a mutation tool.

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

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

A single tight sentence with no filler, front-loading the action and target. Nothing could be trimmed without losing 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 two-parameter boolean toggle with full schema coverage and no output schema, the definition is nearly sufficient — the required inputs are unambiguous. It falls short only on behavioral context (persistence, interaction with playback state, permissions) that the absence of annotations leaves uncovered.

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 both parameters are already documented in structured form (DDR number 1 or 2, boolean enable/disable). The description adds only the gloss that 'DDR' means media player, 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?

Clear specific verb (enable/disable) plus the resource and its controlling field (loop mode on a DDR media player). It does not, however, differentiate itself from the sibling ddr_set_autoplay, which is a closely related per-DDR playback toggle an agent could easily confuse it with.

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 states what the tool does but gives no guidance on when to use it versus ddr_set_autoplay, ddr_play, or ddr_stop, and no prerequisites or state conditions. The agent is left to infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden. The 'stop/pause' ambiguity is unresolved - does it halt and reset, or merely pause resumable playback? No mention of idempotency, state side-effects, or error behavior when the DDR is already stopped.

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 wasted words, front-loaded with the action. Efficient, though the 'stop/pause' slash construction trades precision for brevity.

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?

Adequate for a trivial one-param, no-annotation tool with full schema coverage, but the unresolved stop-vs-pause ambiguity is a real gap given there is no output schema or annotation to clarify the resulting state.

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 has an enum documented in the schema. Baseline 3 applies since the description adds no parameter meaning beyond what the schema already provides.

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

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

States a specific verb (stop/pause) and resource (DDR media player), clearly distinct from siblings like ddr_play or get_ddr_status. The dual 'stop/pause' phrasing is slightly ambiguous about whether these are the same or different behaviors, but the resource and action are 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 and sibling context (ddr_play suggests this is its counterpart), but there is no explicit when-to-use, when-not-to-use, or prerequisites guidance. An agent can infer intent but isn't told about conditions like whether the DDR must be playing 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?

With no annotations, the description carries the full burden. It does not disclose transition duration, whether the call blocks until completion, whether it can be interrupted, or whether the on/off direction is determined by the DSK's current state. For a state-changing switcher operation these are meaningful omissions.

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 wasted words. It is efficient, though its brevity is partly the source of the missing behavioral detail rather than a virtue on its own.

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 state-mutating switcher tool with no annotations and no output schema, the description leaves key questions open: what 'auto' means versus dsk_on/dsk_off, and how the target state is selected when the only parameter is the DSK number. It is not enough to call the tool confidently without inspecting 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?

Schema description coverage is 100% and the single parameter is documented as 'DSK number (1 or 2)' with an enum, so the schema already fully specifies it. The description adds nothing beyond that, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource (auto-transition a DSK layer), which is clearer than a tautology. However, it does not differentiate itself from the closely related siblings dsk_on and dsk_off, leaving the agent to guess what 'auto' adds beyond those two tools. The 'on or off' phrasing also implies a toggle without saying so 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 is given on when to use this tool versus dsk_on, dsk_off, or the general auto_transition sibling. The agent must infer that this performs a transition-effect-driven DSK key change rather than an instant cut, which is exactly the distinction that matters here.

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 disclosure burden. It conveys the outcome (layer leaves air) but says nothing about whether the configured DSK transition is used, whether other layers are affected, required permissions, or whether the action 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 filler; the parenthetical acronym expansion is the only addition and it aids comprehension. Nothing could be removed without losing 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 one-parameter toggle with no output schema and an adjacent dsk_on sibling, the description is nearly sufficient to call the tool correctly. The main missing piece is whether the off-air action uses the layer's transition settings or cuts immediately.

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

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

Schema description coverage is 100%: the single 'dsk' parameter is documented in the schema with an enum of 1 or 2. The description adds no syntax or value meaning beyond that, which is the expected baseline when the schema does the work.

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 ('take a DSK layer off air') and defines the acronym, so an agent knows exactly what state change results. It does not explicitly name the counterpart (dsk_on) or the related dsk_auto, but 'off' versus the sibling names makes the distinction inferable.

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: the verb 'off air' suggests a production-control action for removing a keyer layer from program output. It never states when to prefer this over dsk_auto or dsk_on, nor any prerequisites such as the layer being on air 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?

No annotations are provided, so the description carries the full burden. It does disclose the key behavioral outcome — the layer becomes live/on air — but is silent on whether the cut is instant vs. transitioned (the distinction that separates it from dsk_auto), reversibility, or required state/permissions.

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, no filler, and the action and its effect are front-loaded. 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 one-parameter, no-output-schema tool this is largely sufficient: the resource, the effect, and the enum constraint are all covered. The only gap is the transition/instant behavior that would complete the picture relative to dsk_auto.

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 enum parameter is fully documented in the schema itself ('DSK number (1 or 2)'). The description adds nothing parameter-specific, 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 ('bring ... on air') and resource (DSK layer), and even expands the acronym so an agent unfamiliar with broadcast jargon understands it. It doesn't explicitly contrast with the dsk_off/dsk_auto siblings, but the intent 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?

Usage is only implied by the name and the phrase 'on air' — the agent can infer this is the tool to key a layer live, but nothing states when to pick this over dsk_auto (auto transition) or dsk_off, nor any prerequisite such as a source being assigned to the keyer.

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

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

With no annotations, the description must carry the behavioral load, and it does disclose the key trait: this is a state toggle implemented via an auto transition, not a one-shot effect. It omits secondary details such as fade duration, behavior if already black, or whether other outputs 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?

Two short sentences, purpose front-loaded, toggle semantics immediately follow. 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-param, no-output, unannotated toggle tool, the description covers what it does and how to reverse it. Only the sibling relationship with take_to_black and transition timing are left unaddressed.

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 clarify; baseline is 4. The description correctly implies no arguments 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?

Specific verb+resource: fades the program output to black, and it names the mechanism (auto transition). However, it never distinguishes itself from the sibling take_to_black, which an agent must choose between.

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?

Gives clear usage context by explaining the toggle: calling it a second time fades back up from black. There is no explicit when-not guidance or comparison against take_to_black, so it stops short of the top score.

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

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

With no annotations, the description carries the full load, and it does disclose that the call is a non-mutating read returning a mixer summary — important safety context. It stops short of describing scope for multi-channel systems or any failure behavior, which keeps it out of 5 territory.

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 tight sentences with the resource and the returned fields front-loaded, followed by a return-value summary. No filler, no restatement of the tool name.

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

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

Given a 0-parameter read tool with no output schema, the description supplies the essential missing piece by naming what comes back (mute status and volume levels, a mixer summary). It is complete enough to invoke correctly, with only minor gaps around multi-channel 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 takes zero parameters, so the baseline is 4 and there is nothing for the description to compensate for. No parameter-level detail is required 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?

States a specific verb+resource ('Get the current state of all audio channels') and enumerates what the state contains (mute status, volume levels). It reads as a clear read-side counterpart to set_audio_volume/set_audio_mute, though it never names a sibling explicitly, so differentiation is inferred 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?

The read-only framing implies when to use it (querying mixer state), but there is no explicit guidance about when to prefer it over siblings like get_switcher_state or get_stream_state, nor any prerequisites or exclusions. 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that it returns all current key/value pairs and that these are live data fields, which adds useful context. However, it never explicitly states the operation is read-only or side-effect-free, and no other behaviors are described.

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 redundant or filler content. 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 zero-parameter getter with no output schema and no annotations, the description provides sufficient detail: it explains what DataLink is and what the return values represent. Nothing essential 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 the description's role in parameter semantics is minimal. The baseline score of 4 applies for no-parameter tools.

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 'DataLink key/value pairs', then clarifies with examples like scores and time. This distinguishes it from the sibling set_datalink, which performs the complementary write.

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, when-not-to-use, or alternative tools are mentioned. The description does not guide an agent on when to call this versus set_datalink or other getters.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether the call is safe/read-only, whether it polls live state versus cached state, or what an unknown/inactive DDR returns. It implies safety by saying 'Get ... status' but never confirms it, which is a meaningful gap for a zero-annotation tool.

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

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

One sentence, front-loaded with the verb and resource, followed by the precise fields returned. No filler, no redundancy, every clause earns its place.

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

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

There is no output schema, so the enumerated field list (playback state, timecode, clip name, loop, autoplay) usefully previews the return payload. However, without annotations or an output schema, the description leaves the safety profile and error/unknown-value behavior unaddressed for a one-param tool, which is adequate but incomplete.

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

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

Schema description coverage is 100% and the single parameter is a constrained enum of 1 or 2, so the schema fully documents the DDR selector. The description adds nothing param-specific, which is the expected baseline when the schema does the heavy lifting and only one parameter exists.

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 (DDR status) with the expanded acronym and enumerates the fields returned (playback state, timecode, clip name, loop, autoplay). Clearly a read operation distinct from the mutation siblings ddr_play, ddr_stop, ddr_set_loop, ddr_set_autoplay. Lacks explicit sibling routing but the verb distinguishes 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?

Usage is implied by the verb 'Get' and the status-reporting purpose, but there is no explicit when-to-use or when-not-to-use guidance relative to get_audio_state, get_switcher_state, or the DDR control siblings. An agent can infer this is the read companion to the DDR setters, but that inference is 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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation via 'Read' but doesn't state read-only status explicitly, nor does it disclose error behavior for invalid keys or the return format. The lack of annotations means more disclosure would be beneficial.

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 concise sentences: the core action is stated first, followed by a useful list of example keys. No wasted words.

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 1-parameter read tool with no output schema, the description covers the basics. But without annotations, it should specify that the operation is read-only (no side effects) and perhaps mention the structure of the returned dictionary. The example keys compensate somewhat.

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

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

Schema coverage is 100%, so the schema fully documents the single 'key' parameter. The description adds a list of example keys, which is helpful context but largely repeats the schema's example. 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 clear verb (Read) and resource (TriCaster state dictionary by key), distinguishing it from siblings like get_switcher_state or get_tally. However, it doesn't explicitly differentiate itself from those narrower getters, leaving some ambiguity about when this generic dictionary read is preferred.

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 listing of common keys implies usage context, suggesting this tool can fetch a variety of states. But there's no explicit guidance on when to use this generic tool versus the many specific get_* 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?

With no annotations, the description must carry the behavioral load. It usefully discloses the return value space (active/inactive), which is real information absent from the schema, but says nothing about permissions, whether the read is side-effect free, or what happens with an invalid recorder number.

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

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

Two short sentences, zero waste, and the core purpose is front-loaded ahead of the optional parameter note.

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 getter with no output schema, the description covers the essentials and describes the returned states. It is nearly complete, with only minor gaps around error conditions or per-recorder semantics.

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 already documents its default, so the description's "default: 1" merely restates it. Baseline 3 is appropriate 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?

States a specific verb (Get) and resource (record state) plus the value space (active/inactive), which is more than a tautology. It is distinguishable from start_record/stop_record by name, but the description offers no explicit differentiation from those 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?

There is no statement of when to call this versus start_record, stop_record, or get_stream_state. Usage is only implied by the name; the only guidance given concerns the optional parameter, not the tool's role.

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

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

No annotations provided, so the description carries the full behavioral burden. It conveys read-only intent implicitly but says nothing about permissions, whether state is instantaneous or cached, or what values beyond active/inactive might appear. Minimal disclosure for a tool with zero annotation coverage.

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 wasted words.

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-param read tool this is arguably adequate, but with no annotations and no output schema, the description is the only source of behavioral context and it leaves the return shape (beyond 'active/inactive') and permissions unstated.

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. 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 (get) and resource (streaming state) with the return value named (active/inactive). Distinguishable from nearby siblings like start_stream/stop_stream and from get_audio_state, though it doesn't explicitly name a 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?

No when-to-use guidance, no mention of alternatives or related tools (start_stream, stop_stream, get_record_state). The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden. 'Get' implies a read-only operation, and the listed fields usefully disclose the scope of returned data. However, it does not state whether this is a safe, side-effect-free read, nor does it mention polling/rate considerations or consistency of T-bar position during transitions.

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 sentence that front-loads the core purpose and then lists the specific fields. No filler, no repetition.

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

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

For a parameterless read tool with no output schema, the description adequately specifies what information is returned. It could be slightly more complete by confirming the read-only nature and whether values reflect live program/preview output.

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 document. Baseline for zero-parameter tools is 4, and the description correctly avoids any misleading parameter discussion.

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 ('switcher state'), then enumerates exactly what state is returned: Program source, Preview source, active effect/transition, T-bar position. This distinguishes it from siblings like get_record_state, get_stream_state, and get_audio_state, which each target different subsystems.

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-to-use guidance is given. Use is implied by the tool name and read-only nature, but the description does not compare it against alternatives or mention preconditions.

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

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

With no annotations, the description carries the full burden, and 'Get' does imply a non-mutating read, which is the key behavioral fact here. However, it says nothing about connection/permission requirements, error behavior when no session is active, or whether values are live vs cached — acceptable for a trivial zero-arg read, 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?

One sentence, front-loaded with the verb and resource, and every element (the listed fields) adds information. There is no padding or 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?

There is no output schema, so the description usefully compensates by naming the returned values, and with zero parameters there is little else an agent needs. It stops short of stating anything about session state or failure conditions, leaving 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 per the baseline rule a 4 applies; there is nothing for the description to disambiguate. The listed output fields are informative but are not parameter semantics.

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 a clearly bounded resource, and it enumerates the exact fields returned (model, version, session name, resolution), which separates it from status getters like get_switcher_state or get_audio_state. It never explicitly names a sibling to avoid, but the resource is unique enough that no reasonable agent would confuse 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?

The description gives no when-to-use guidance, no prerequisites, and no mention of alternatives. Usage is only inferable from the tool name itself, so an agent gets no explicit routing signal.

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 exist, so the description carries the full disclosure burden. It does convey the domain semantics of the return (which sources are live on Program vs Preview), which is useful context, but it never states that this is a non-mutating read or anything about freshness, polling, or result 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 sentence with the action front-loaded and the interpretive gloss placed after an em dash. No filler, 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 annotations and no output schema, the description must stand alone, and it does explain the substance of what comes back (per-input Program/Preview status). It stops short of describing the result structure or how quickly the state reflects a transition, which is the only real gap for a zero-argument read.

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; the baseline for a parameterless tool applies. The sentence about Program vs Preview is about the result, not an 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?

States a specific verb and resource ('Get tally state for all inputs') and then defines the domain term by unpacking it into Program vs Preview sources. That is clear enough to distinguish it from siblings like get_switcher_state and get_stream_state, though no sibling is named or explicitly ruled out.

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 mention of when to prefer this over get_switcher_state or list_sources, and no note on polling cadence or prerequisites. Usage is only inferable from the semantics of 'tally'.

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. 'List' implies a safe read and the 'system and session' scoping is genuinely useful behavioral context, but nothing is said about permissions, result ordering, or any side effects for session macros.

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 resource and the scope of results come first. Every clause earns its place.

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

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

There is no output schema, so the description correctly specifies what comes back ('by name and ID') and which macro categories are included. For a zero-parameter list tool this is nearly complete, missing only a pointer to the related run_macro action.

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

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

The tool takes zero parameters, so the baseline is 4. The schema is empty and there is nothing 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 ('List all available macros') and scopes the result set to system and session macros. It implicitly distinguishes itself from the write-side sibling run_macro, but never names or otherwise differentiates from it 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: an agent can infer this is the discovery step before run_macro, but the description never says when to call it, when not to, or that run_macro is the companion action. No exclusions or prerequisites 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?

No annotations are provided, so the description carries full burden. It discloses the conceptual return (source names) but doesn't detail format, ordering, or whether it reflects live state. Adequate but not rich for a discovery tool.

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

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

Two tight sentences, front-loaded with purpose then immediately followed by the actionable workflow cue. No waste.

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 it's a zero-param discovery tool with no output schema, the description supplies the essential purpose and usage routing. Minor gap: no hint about what the returned names look like or whether they're stable identifiers.

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 baseline 4. Description adds nothing needed beyond confirming no filtering 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 (List) and resource (input sources) with concrete examples of what a source is (inputs, DDRs, buffers, graphics). This clearly distinguishes it from the sibling switch_program/switch_preview tools, which it explicitly references.

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?

Explicitly states when to use it: 'to discover valid source names before calling switch_program or switch_preview.' This ties usage to a concrete prerequisite workflow, routing the agent correctly.

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

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

No annotations are provided, so the description carries the full burden and it does not disclose any behavior: whether execution is synchronous or fire-and-forget, what happens if the macro name is unknown, what side effects the macro triggers, or whether permissions are required. For an action/execution tool this is a substantial 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 or redundancy. Its brevity is efficient, though it edges toward 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 an execution tool with no annotations and no output schema, the description says nothing about effects, failure modes, or return behavior. The single parameter is covered by the schema, but the behavioral context an agent needs to call this safely 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?

There is a single parameter with 100% schema description coverage ("Macro name as shown in the macro list"), so the schema already documents it fully. "By name" in the description adds nothing beyond the schema, making the baseline 3 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 gives a specific verb plus resource ("Execute a macro") that clearly identifies an action tool, and "by name" hints at the input it needs. It does not, however, mention or contrast with the sibling list_macros, so an agent gets no explicit differentiation cue.

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 tool versus alternatives, no prerequisite that the macro must already exist, and no reference to list_macros as the way to discover valid names. Usage must be inferred entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says it sends a raw command but does not state what happens on execution, whether it requires authentication, whether changes are reversible, what errors may occur, or any rate limits—critical gaps for a low-level control tool.

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

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

Two sentences with zero waste. The purpose is front-loaded, and the second sentence immediately clarifies the use case and differentiator from other tools.

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 that executes arbitrary raw commands, the description gives enough to select it but not enough to invoke it safely or effectively. It lacks guidance on where to find valid shortcut names, how the optional value is interpreted, or what the tool returns, and with no annotations or output schema, those gaps are significant.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (name and optional value). The description adds no additional meaning about parameter syntax, allowed values, or format beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb (send) and resource (raw shortcut command to TriCaster), and distinguishes itself from siblings by positioning as advanced/custom control not covered by other tools. An agent can tell it apart from specific tools like set_audio_volume or dsk_on 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?

It explicitly says to use this for advanced/custom control not covered by other tools, which is a clear when-to-use condition and an implicit when-not (for covered controls). It does not name any specific alternative sibling tools, so it falls short of the highest bar.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the action and lists valid channels, saying nothing about side effects, reversibility, permissions, or success/failure behavior—a significant gap for a mutation tool.

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

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

Two short sentences, front-loaded with the action and followed by the essential channel list. Every sentence earns its place; 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 simple setter with 100% schema coverage and no output schema, the description covers the action and full channel enumeration. However, with no annotations it lacks any behavioral context (e.g., idempotency, auth requirements), leaving a minor but real 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%, establishing a baseline of 3, but the description adds meaning beyond the schema by enumerating the complete set of valid channel names ('master', 'input1'–'input8', 'ddr1', 'ddr2', 'aux1', 'phones'). This compensates for the lack of an enum constraint in 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 ('Mute or unmute') and resource ('an audio channel'), and the action verb cleanly distinguishes it from siblings like set_audio_volume (volume change) and get_audio_state (read). An agent can tell what it does 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?

No explicit guidance on when to use this tool versus alternatives such as set_audio_volume or get_audio_state. Usage is only implied by the verb 'mute or unmute'; there are no when/when-not conditions or named alternatives.

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

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

No annotations, so the description carries the burden. It usefully explains the value semantics (0 = unity, negative = lower, positive = louder), which is real behavioral context beyond the bare schema. However it omits whether the set is instant or ramped, whether it persists, and any permission/state preconditions for a mutation tool.

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

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

Three tight sentences, purpose front-loaded, followed by value semantics and channel list. No filler; every clause earns its place.

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

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

For a two-param, no-output-schema mutation tool with no annotations, the description supplies the essential missing pieces (gain semantics and the channel vocabulary). It stops short of stating behavioral side effects or error conditions, but is close to 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?

Schema coverage is 100% (baseline 3), and the description adds genuine meaning: it enumerates the valid channel names ('master', 'input1'–'input8', 'ddr1', 'ddr2', 'aux1', 'phones'), which the schema only illustrates with examples and no enum. The gain semantics reinforce the volume param.

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?

Clear verb+resource: 'Set the volume (gain) of an audio channel.' Distinguished from its closest sibling set_audio_mute (on/off vs level) though it does not name that sibling explicitly. The scope 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?

Usage context is implied (adjusting an audio channel's level) but there is no explicit when-to-use vs alternatives, nor does it contrast with set_audio_mute or get_audio_state. Adequate but leaves routing 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?

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It does not say whether the value overwrites existing data, whether the write persists across sessions, whether permissions are required, or what the tool returns on success/failure.

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 the action front-loaded and the clarifying example parenthesized at the end. Nothing is wasted, though there is little structure to speak of beyond that one line.

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 tool with full schema coverage, the description is adequate to invoke it, but a mutation operation with zero annotations and no output schema leaves the agent uninformed about overwrite semantics, persistence, and the relationship to get_datalink.

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 both parameters are documented there, so the baseline is 3. The description adds only a light hint about the kinds of values ('score or text field') and no syntax, format, or key-naming convention 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+resource ('Set a DataLink key to a value') and gives a concrete example of the domain ('update a score or text field'). It implicitly contrasts with the sibling get_datalink, though it never names it, so it falls just short of full 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as get_datalink for reading the same key. The example hints at typical use cases but does not state conditions or exclusions.

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

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

With no annotations, the description carries the full burden. It does disclose scope ('main background switcher') and that it sets an 'active' effect rather than performing a transition, but it does not say whether the change is immediate, persistent, or requires a subsequent transition, nor any permission requirements.

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 tight sentences with no filler; the core action is front-loaded and the discovery hint follows immediately. Every clause earns its place.

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

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

For a single-parameter tool with no output schema, the description covers the action, scope, examples, and how to find valid values. It would be fully complete if it stated whether the effect applies immediately or at the next transition.

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 baseline is 3, but the description adds real meaning: it clarifies that the value can be any effect name from the effects bin, not just the listed examples, and points to get_switcher_state for the authoritative list.

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 (set) and resource (active transition effect on the main background switcher) and supplies concrete examples ('Cut', 'Dissolve', 'Wipe'). It is clear, though it does not explicitly distinguish itself from siblings like cut_transition or auto_transition, which also deal with transitions.

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?

It points the agent to get_switcher_state to discover valid effect names, which is useful routing guidance. However, it gives no guidance on when to use this configuration tool versus executing tools like cut_transition or auto_transition, leaving the usage context 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?

No annotations are provided, so the description carries the full behavioral burden. It only restates the action and the parameter default, and does not disclose whether starting an already-recording session errors or is ignored, what permissions are needed, or what the call returns.

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

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

Two short sentences, front-loaded with the core action and then the optional parameter detail. Nothing is wasted and the structure is appropriate for this simple 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?

The tool is low-complexity and the schema fully covers the only parameter, but with no annotations and no output schema, the description could do more to explain state implications or expected behavior. It is minimally adequate but leaves behavioral 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 100% and the single 'recorder' parameter is fully documented in the schema. The description repeats the default but adds no new meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a clear verb and resource: 'Start recording.' This distinguishes it naturally from siblings like stop_record and get_record_state. However, it does not explicitly differentiate its scope from related tools such as start_stream or explain which recorder is affected beyond the optional parameter.

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. It does not mention stop_record, get_record_state, start_stream, or any conditions or exclusions. Usage is only implied by the tool 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?

With no annotations provided, the description carries the full behavioral burden, but it discloses nothing about side effects, failure modes (e.g., already streaming, no configured destination), idempotency, or expected state change. For a live-broadcast mutation this is a meaningful 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 short sentence, front-loaded with the action. It is efficient, though its brevity reflects under-specification rather than tight editing of a rich description.

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 streaming control with no output schema and no annotations, an agent still needs to know prerequisites (stream key/target configured), the resulting state, and how it pairs with stop_stream and get_stream_state. None of that is provided, leaving the definition incomplete for the operation it performs.

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 are no arguments whose meaning the description would need to supplement.

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: 'Start streaming.' However, the qualifier 'on the primary streamer' adds little and the description never distinguishes this from siblings like start_record or explains the relationship to stop_stream/get_stream_state, so no sibling differentiation is present.

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 versus start_record, nor any precondition such as a configured stream target or a warning about calling it while already streaming. The agent is left to infer the entire usage context from the name alone.

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

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

No annotations are provided, so the description must carry full behavioral burden. It does not disclose whether stop is reversible, what happens to the recording file, whether it requires the recording to be active, or any side effects. This is a significant gap for a mutation/write tool.

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

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

Two short sentences, front-loaded with the core action and followed by an optional detail. Every word earns its place with no waste.

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 recording-stop tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens on stop, whether a recording must be in progress, or any return value implications. The agent lacks critical context to invoke it 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?

Schema coverage is 100%, so the schema already documents the 'recorder' parameter and its default. The description adds the default value redundantly but no additional meaning beyond the schema. Baseline 3 is appropriate when schema does the work.

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: 'Stop recording.' This clearly distinguishes it from start_record and other siblings. It is concise and unambiguous, though it does not explicitly name the alternative.

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

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

The description implies when to use it (to stop an ongoing recording), which is reasonably clear from the name and description. However, it does not explicitly state when-not-to-use or name alternatives like start_record, leaving some inference to the agent.

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

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

With no annotations, the description carries the full burden. It does not disclose whether stopping is disruptive/hard to reverse, whether it is idempotent when no stream is active, what happens to the stream connection, or what errors to expect. 'Primary streamer' also leaves unaddressed whether multiple stream targets 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?

A single twelve-word sentence, front-loaded with the action and the target. Nothing is wasted, though the brevity is arguably 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 zero-parameter action tool with no output schema the description technically suffices, but with no annotations the safety/disruption profile of stopping a live stream is left entirely unstated. Minimum viable, with a clear gap in behavioral 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No param syntax 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?

States a specific verb (Stop) and resource (streaming) with the scope qualifier 'on the primary streamer', which is enough to distinguish it from start_stream and get_stream_state among the siblings. It stops short of naming the alternative explicitly, but 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?

There is no guidance on when to call this versus start_stream, get_stream_state, or the recording counterparts, and no stated preconditions (e.g. must a stream be live). Usage is only implied by the verb.

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 does disclose the critical non-destructive aspect ('without going to air') which is valuable behavioral context. But it doesn't mention whether this affects the current preview state irreversibly, permissions, or any side effects—moderate transparency at best.

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 key action and constraint. No wasted words. Could be slightly more efficient by integrating the list_sources hint more smoothly, but it's tight and purposeful.

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

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

For a simple mutation tool with no annotations and no output schema, the description covers the essential 'what' and a key constraint, but omits any return behavior, error conditions, or timing considerations (e.g., does it take effect immediately?). Adequate but with clear gaps for full contextual completeness.

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 parameter documentation is already in the schema with examples ('input2', 'ddr1', 'gfx2'). The description only adds the reference to list_sources for valid names, which is marginal. Baseline 3 when schema does the heavy lifting.

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

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

The description states a specific action ('set the Preview row to a new source') and explicitly disambiguates from going to air, which is critical distinction. However, it doesn't explicitly contrast with the sibling 'switch_program' which appears to be the on-air counterpart. Still clear enough about what it 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?

The description implies this is the preview operation (not on-air) and directs to list_sources for valid names, which is implied usage guidance. But it doesn't explicitly say when to use this versus switch_program or other transition tools, leaving some ambiguity for an agent unfamiliar with the switcher 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?

With no annotations, the description carries the full behavioral burden. It discloses that the switch is immediate and skips transitions, and points to a discovery tool. However, it omits permissions, reversibility, error behavior, and whether preview is affected, leaving notable gaps for a live production control.

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?

Three compact sentences, front-loaded with the core action. The follow-up sentences add source discovery and examples without waste. 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 simple one-parameter control tool with full schema coverage, no output schema, and no annotations, the description provides enough to call it correctly: what it does, how to discover valid sources, and common values. No essential information 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?

Schema coverage is 100% and provides examples, so the baseline is 3. The description adds meaningful value by directing agents to list_sources and expanding the example enumeration (inputN, ddr2, gfx2, bfr1–bfrN), which helps agents construct valid 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 and resource: 'Cut directly to a new Program source.' The parenthetical '(no transition)' distinguishes it from sibling transition tools like auto_transition and cut_transition. An agent can identify the action 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?

Provides clear context: use list_sources for valid names, and common sources are listed. The 'no transition' phrasing implies when this tool is appropriate versus transition-based siblings, though it does not explicitly name alternatives or when-not-to-use cases.

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

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

No annotations are present, so the description carries the full burden. It correctly discloses the instant/no-transition behavior, but says nothing about reversibility, how to restore program output, or whether this affects only the program bus versus preview — gaps for a state-mutating switcher command.

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 differentiator. 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 zero-parameter tool with no output schema this is nearly sufficient, but nothing explains the operational consequence — e.g. how an agent returns from black — and with no annotations to fall back on that leaves a real 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 there is nothing for the description to clarify beyond the schema. 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 action (cutting program output to black) with a precise qualifier ('instantly', 'no transition'). This implicitly separates it from the sibling fade_to_black, so an agent can pick the right one without opening either 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 explicit 'use this when...' guidance, but '(no transition)' combined with 'instantly' strongly implies the contrast with fade_to_black. Usage is inferred rather than stated.

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