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 one trait ('Unknown routes capture once for learning'), which is useful, but says nothing about permissions, side effects, or whether route execution can alter device 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?

Three dense clauses, tightly packed with zero filler and front-loaded with the primary action. It borders on terse given how much it crams into shorthand.

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?

An output schema exists so return values need no explanation, but for a 4-param, annotation-free tool whose schema documents nothing, the description is too thin to cover operation semantics or the capture behavior adequately.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that value means an advertised-metadata query, an LG-browser URL, or a YouTube ID depending on operation, but leaves app_id and the capture enum (auto/never/always) unexplained beyond the offhand 'capture once' phrase.

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 phrase 'Execute bounded native app route' states an action but relies on jargon ('bounded', 'route') that is not self-explanatory. Combined with the operation enum it is inferable as driving a TV app, but it does not clearly differentiate from the sibling tv_launch.

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 does route some operations implicitly ('URL is LG browser only; video accepts YouTube ID'), giving conditional guidance for the open_url and youtube_video paths. But it never names when to use this versus tv_launch or tv_apps, leaving the core selection decision to inference.

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

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

With no annotations, the description carries the full burden. It discloses the data domain (app versions, learned and native routes) but does not state whether the operation is read-only, what side effects occur, or how results are returned. This is partial transparency for a zero-parameter tool.

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

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

The description is a single short sentence, so it is concise, but it is a fragment lacking a verb and not front-loaded with actionable information. Structure is weak despite 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?

For a zero-parameter tool with no output schema or annotations, the description should explain what the tool returns and when to invoke it. It provides only a bare list of data categories, leaving the agent unable to confidently select it over numerous siblings.

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

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

The tool has zero parameters, so the schema description baseline is 4. There is nothing for the description to add or clarify regarding parameters.

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

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

The description is a noun phrase listing data types ('Installed app versions, learned routes and native routes') but never states an action verb or what the tool actually does. It does not distinguish this tool from siblings like tv_discover or tv_learn.

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 indication of when to use this tool, what prerequisites exist, or which alternatives (e.g., tv_discover, tv_learn) it replaces. The agent is left to infer usage entirely.

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 hints that visual context is needed, but does not disclose side effects, safety profile, or what happens on click.

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 the action, though the semicolon clause could be slightly clearer.

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 has one parameter with an enum and an output schema, but the description does not explain the capture modes or when they matter. With no annotations and no parameter descriptions, the definition leaves an agent under-informed for correct invocation.

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

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

Schema description coverage is 0% and the description never mentions the single 'capture' parameter or its enum values (auto, never, always). The description adds no meaning beyond the bare 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 action (click) and scope (current pointer position), which distinguishes it from generic UI actions. It does not explicitly differentiate itself from siblings like tv_select or tv_press, but the core purpose is 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?

It provides a prerequisite condition: 'requires a known target or fresh visual observation.' However, it does not say when to use this tool versus alternatives such as tv_press or tv_select, nor does it state 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 of behavioral disclosure. It adds a useful caveat about duplicate IPv4 addresses being ambiguous, which is a real operational trait, but it does not clarify read-only status, return format, authentication needs, or side effects.

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

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

The description is very brief and front-loads the resource ('Known paired TVs'). The following clause adds a useful caveat. It is appropriately sized for a simple zero-parameter tool, though the second clause is somewhat cryptic without context.

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

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

For a simple zero-parameter tool with no output schema, the description covers what the tool deals with and one ambiguity caveat. However, it does not clarify when to use it over sibling tools, what the return value looks like, or how it relates to tv_discover and tv_select, leaving important context 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?

The tool has zero parameters, so there is no parameter schema to compensate for. The baseline for no parameters is 4. The description's reference to selecting by name/ID does not map to any parameter and is more relevant to usage than 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?

The description identifies the resource ('Known paired TVs') but uses a noun phrase rather than a clear action verb like 'list' or 'retrieve'. It does not explicitly state what the tool does with those devices, leaving the purpose vague and relying on the agent to infer that it returns the known devices.

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 gives some practical guidance ('Select by name/ID; duplicate IPv4 addresses are ambiguous') but does not explain when to use this tool versus sibling tools like tv_discover or tv_select. The usage context is implied rather than explicit, and no exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden, and it does disclose one meaningful behavioral trait: discovery requires neither pairing nor subnet scanning. It still omits other traits such as how discovery is performed, whether it blocks, timing, or network prerequisites.

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

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

A single front-loaded sentence with no wasted words; the key purpose and constraint are immediately visible.

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 an output schema exists (so return values need no explanation) and there are no parameters, the description is nearly sufficient for a simple discovery tool. It could be slightly more complete by noting the discovery mechanism or any prerequisites, but it covers the essentials.

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 rubric the baseline is 4. The description adds no parameter meaning because there are none to clarify.

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

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

States a specific verb ('Find') and resource ('LG TVs'), and adds a distinguishing condition ('without pairing or subnet scanning') that separates it from other discovery approaches. However, it does not explicitly name or contrast with a sibling tool such as tv_devices or tv_select, so the agent must infer the boundary.

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

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

The phrase 'without pairing or subnet scanning' implies the context in which this tool is appropriate (lightweight discovery), but it does not explicitly say when to prefer it over siblings like tv_devices or tv_select. Usage is implied rather than stated with 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, and it only hints at behavior ("learned route avoids image capture"). It does not say what "non-stub" excludes, what permissions are needed, how failures surface, or how the learned route is chosen.

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, though the second clause is cryptic enough that brevity comes partly at the cost of 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?

An output schema exists, so return values need not be described, but for a launch tool with zero annotation coverage and 0% parameter description coverage the description leaves too much unexplained to call this complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it only obliquely touches the capture parameter ("avoids image capture") without explaining the auto/never/always enum, and app_id is never addressed.

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?

It gives a verb ("Launch") and a resource ("installed non-stub app"), so the core action is identifiable, but "non-stub" and "learned route" are unexplained jargon and there is no differentiation from nearby siblings like tv_app_action or tv_apps.

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

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

There is no statement of when to use this versus tv_app_action, tv_apps, or tv_ui_run, and no prerequisites or exclusions. The agent must 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?

With no annotations, the description carries the full burden. It implies a persistent side effect (creating a reusable addon) but does not say whether the addon is actually saved, where, whether it is reversible, or what permissions/state the witness_id must satisfy. Only the 'visually verified first' precondition is disclosed.

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

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

Two sentences, no filler, with the precondition front-loaded before the action. Efficient, though the second sentence's guidance is bolted on rather than structured.

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

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

For a no-annotation, no-output-schema tool with 0% parameter coverage and an apparent write/persistence effect, the description leaves major gaps: what a 'route' or 'addon' is, what witness_id references, and what the result looks like.

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 0%, so the description must compensate. It usefully constrains 'notes' (record what the image actually proved) but leaves 'witness_id' entirely unexplained in both schema and description, so half the parameters remain opaque.

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 verb ('compile') and an artifact ('reusable addon') but relies on unexplained jargon ('route', 'addon') that the agent cannot map to a concrete output. It is distinguishable from siblings like tv_observe or tv_discover by the learning/persistence framing, but the actual effect remains fuzzy.

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 opening clause gives a sequencing precondition: run this after visually verifying the latest native action or UI recording screenshot. That is real when-to-use guidance, but no alternatives are named and no case is given for when not to learn a route.

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 usefully discloses that movement is relative (dx/dy are deltas), but says nothing about the capture modes' effects, whether movement is animated/instant, or permission/error behavior for a mutation-like pointer action.

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 followed by the safety hint. No wasted words, though the extreme brevity is partly under-specification rather than economy.

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?

An output schema exists so return values need not be described, but with no annotations and 0% parameter coverage the description leaves the capture parameter and the tool's behavioral profile unaddressed. For a 3-parameter pointer tool it is thinner than needed.

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 0%, so the description must compensate. 'Relative pointer' correctly frames dx/dy as deltas, but the capture enum (auto/never/always) is entirely unexplained in both schema and description, leaving one of three parameters opaque.

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 ('Move relative pointer') and the 'relative' qualifier distinguishes it from an absolute-position move. It never names or contrasts with siblings like tv_click or tv_scroll, 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?

'Inspect unknown target before clicking' implies the tool is a precursor to a click on unverified targets, giving implied usage. It does not state when to prefer tv_move over tv_scroll or tv_ui_anchor, nor any exclusion conditions.

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

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

With no annotations, the description carries full behavioral burden. It usefully discloses side effects of the modes (auto may register/capture unknown apps; always forces a fresh screen), which implies a possible write side effect, but it never states read-only vs mutating intent, permission needs, cost, or what "never" changes.

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 compact sentences, purpose first then mode behavior, with no filler. It is efficiently front-loaded, though the extreme brevity leaves real gaps that a slightly longer definition could have closed.

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?

An output schema exists, so return values need not be described, and there is only one optional parameter. However, the definition still leaves the tool's role relative to tv_apps/tv_discover unclear and does not cover the "never" mode, so it is only minimally complete for its purpose.

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

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

Schema description coverage is 0% and the enum values carry no documentation, so the description must compensate. It directly explains the behavior of two of the three enum values (auto captures unknown apps, always requests a fresh screen), leaving only "never" to inference.

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?

"Lightweight app/audio state" tells the agent the resource under observation (app/audio state) but supplies no verb and no scope statement, so it reads more like a noun phrase than a stated action. It does not distinguish itself from siblings like tv_apps or tv_discover, which likely also surface app information.

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

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

The second clause explains what two capture modes do, not when to choose this tool over siblings. There is no guidance on when observation is preferable to tv_apps, tv_discover, or tv_ui_anchor, and no prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the full behavioral burden. It discloses two important traits: wake depends on network-standby support, and an unreachable device does not prove it is powered off, plus that power state is verified natively. It omits whether power off is graceful vs hard, permission/auth needs, and what wait_seconds actually blocks on.

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 short, front-loaded sentences with no filler; the primary capability leads and the caveats follow. Efficient, though the 'Unreachable...' sentence reads as a warning fragment rather than fully integrated guidance.

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 2-parameter, no-annotation, no-output-schema tool, the description covers the core action and key caveats but leaves the 'status' operation, wait_seconds semantics, and any return/verification detail unexplained. Adequate minimum, with clear gaps an agent would have to guess around.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It loosely maps to 'off' (power off natively) and 'on' (wake registered MACs) but never addresses the 'status' enum value or what wait_seconds controls (the default 20 is unexplained).

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 concrete verbs and resource: power off natively, wake registered MACs, verify native power state. Clearly separable from sibling UI/input tools like tv_press or tv_launch, though the third operation ('status') is never named explicitly.

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

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

Provides one real precondition ('Wake requires TV network-standby support') and a useful caveat ('Unreachable is not proof of power off'), which implicitly guides when a status check is warranted. However, it never says when to use this tool versus siblings such as tv_launch or tv_observe, nor how to choose between the three operations.

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

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

With no annotations, the description carries the full burden. It does disclose one real behavioral caveat — foreground state cannot identify the focused control, so navigation must be verified visually — but says nothing about side effects, key queuing, or what 'bounded' means operationally.

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

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

It is short (two fragments of ~14 words), but the brevity is under-specification, not conciseness — the telegraphic phrasing conveys little usable information. It is front-loaded, though that content is cryptic.

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?

An output schema exists, so return values need not be explained, but for a two-parameter mutating tool with no annotations and 0% schema coverage the description is far too thin. The meaning of 'bounded' and the capture parameter are never resolved.

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

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

Schema description coverage is 0% and the description does not explain either parameter. 'Remote key' loosely gestures at the button enum, but the capture parameter (auto/never/always) is entirely unexplained despite having a meaningful behavioral effect.

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 phrase 'Bounded remote key' is a verbless fragment that only hints at sending a remote key press, and the rest of the description is about verification rather than what the tool does. It distinguishes weakly from siblings like tv_click or tv_move, but never states the action+resource directly.

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?

'Observe unknown navigation visually' hints that results must be confirmed with an observation tool, but explicit when-to-use/when-not and routing to alternatives (e.g., tv_click vs tv_press) are absent. Only a fragment of guidance is present.

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 disclosure burden. 'Bounded scrolling' and 'automatic unknown-app fallback' hint at clamping and a fallback path, but neither is explained, and nothing is said about permissions, side effects, or state changes beyond the vague phrase 'lightweight 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?

It is a single short sentence with no padding, so it is structurally tight. However, the brevity comes at the cost of under-specification rather than achieved 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?

An output schema exists so return values need not be described, but with two undocumented parameters (0% coverage), no annotations, and only vague behavioral hints, the definition is not complete enough for an agent to invoke the tool confidently.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate and it does not. Neither 'dy' (direction/amount?) nor the 'capture' enum (auto/never/always) is mentioned, leaving their meaning and accepted values entirely to inference.

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 the resource (scrolling) but the verb is only implied and the modifier 'bounded' is ambiguous. It does not distinguish tv_scroll from siblings like tv_move, tv_press, or tv_click, and never states that this scrolls a TV UI surface.

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 or when-not-to-use guidance and no reference to any alternative tool. The only contextual hint is 'automatic unknown-app fallback,' which is a behavior, not a selection rule.

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 two useful traits—identity verification and no implicit pairing—but omits whether selection persists, required permissions, side effects, or failure behavior for a selection operation.

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

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

Two compact sentences with no wasted words. The action is front-loaded and the constraint is placed immediately after it.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description covers the main action and one constraint. It remains incomplete about what selection returns or changes, and about error conditions.

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 0% and the single 'device' parameter has no schema description. The description compensates partially by stating it accepts name or ID, but gives no format examples or validation details.

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

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

The description states a specific verb ('Select') and resource ('registered TV'), and clarifies the accepted identifier forms ('by name or ID'). It does not explicitly name or differentiate from sibling tools such as tv_discover or tv_devices, so it falls short of the highest clarity tier.

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 gives an implied usage context ('Select a registered TV') and one important exclusion ('Never pair implicitly'). However, it does not say when to choose this over alternatives like tv_discover or tv_devices, leaving 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?

With no annotations, the description carries the full burden, and it does disclose a genuinely valuable trait: some apps (YouTube) ignore the input and acknowledgement does not confirm insertion, so the agent should not trust success. However, it omits matters like error behavior, the meaning of the capture mode, and what 'focused-field' implies about prior 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?

Two tight sentences with the core action front-loaded and the risk caveat following. No filler, though the brevity is partly achieved by leaving parameters unexplained.

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?

An output schema exists, so return values need not be documented, and the caveat covers the main success-verification risk. Still, an unexplained enum parameter and no annotations leave the definition thin for correctly invoking the tool with a non-default capture mode.

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

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

Schema description coverage is 0%, so the description must compensate but does not: the required 'text' parameter is only implicitly referenced, and the 'capture' enum (auto/never/always, default auto) is never explained. An agent cannot infer what capture controls or when to override the default.

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 ('Send focused-field text'), making clear this is the text-entry tool rather than a key-press or click tool among the tv_* siblings. It lacks explicit differentiation from siblings like tv_press or tv_click, but the 'text' focus is distinctive enough for an agent to select 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?

There is no guidance on when to use this versus alternatives such as tv_press or tv_app_action, nor on prerequisites like whether a field must first be focused via tv_click. The caveat about some apps ignoring the input is a behavioral warning, not a usage rule.

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 burden. It discloses important timing and invalidation behavior, including the 30-second screenshot freshness requirement and 60-second context expiration, but it does not state side effects, permissions, return behavior, or error conditions.

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

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

The description is three tight sentences, front-loading the purpose and then adding essential constraints. Every sentence carries useful information without repetition or filler.

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

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

For a two-parameter tool with no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It covers timing and invalidation well but omits the meaning of witness_id, side effects, and what the agent can expect after anchoring 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 0%, so the description must explain both parameters. It indirectly describes what the state parameter should contain (page, focus, keyboard, modal state), but witness_id is never mentioned or explained, leaving a required parameter completely opaque.

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 ("Name") and the exact UI state fields to capture: page, focus, keyboard, and modal state. It also clarifies that selected tab information alone is insufficient, which helps distinguish it from simpler state-reading siblings, though no sibling tool is explicitly named.

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 clearly states the required context: use after inspecting a screenshot taken within 30 seconds, and when selected tab alone is insufficient. It also gives expiration conditions (60 seconds or untracked command/reconnect), which tells the agent when the anchor is no longer valid.

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

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

No annotations are provided, so the description carries the burden. It discloses meaningful constraints: a 1-20 step cap, single-capture semantics, and prohibited content categories. It omits failure behavior, whether the recording is persisted, and any auth/prerequisite needs.

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 the core action and followed by constraints and exclusions. Dense but no filler, though the shorthand ('Inspect then tv_learn') borders on cryptic.

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?

An output schema exists so return values need no explanation, and the description covers the key behavioral constraints. But for a 5-parameter tool with 0% schema coverage and no annotations, the parameter layer remains substantially unexplained.

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

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

Schema description coverage is 0% across 5 params (4 required), and the description only touches one of them ('text $VALUE parameterizes the route'). name, from_state, to_state, and steps receive no explanation of format or meaning, so the description fails to compensate for the coverage gap.

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

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

States a specific action: run 1-20 press/wait/text/replace_text/submit steps from an anchored state and capture the result once. The 'record/capture once' framing distinguishes it from a plain step-runner sibling like tv_ui_run, though it leans on jargon ('anchored state') the agent must resolve elsewhere.

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 explicit when-not guidance ('Never learn loading as completed content, nor purchases, account edits or consent routes') and a workflow hook ('Inspect then tv_learn'). It does not, however, explain how to choose this over tv_ui_run or tv_learn directly.

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

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

With no annotations, the description carries the full burden and does well: it discloses that execution requires tracked origin/app-version match, that invalid context returns a screenshot without executing, and that tracked state is predicted rather than a real TV focus readback, advising re-observation after external remote use. Auth/permission behavior and rate limits are not covered.

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 sentences, front-loaded with the verb, and no obvious padding. The first sentence is awkwardly compressed ('without images only from its tracked origin'), which costs clarity without saving much length.

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?

An output schema exists, so return values need not be explained, and the behavioral caveats are strong. But with zero annotation coverage and 0% schema description coverage, the three parameters are left entirely undocumented, which is a real gap for an execution tool.

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

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

Schema description coverage is 0% across three parameters (app_id, name, value), and the description never maps to them. 'tracked origin and exact app version' loosely hints at app_id, but 'name' and 'value' receive no semantic explanation at all, leaving callers to guess.

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 ('Run generated UI addon'), which is more than a tautology. However, the qualifier 'without images only from its tracked origin and exact app version' is garbled and hard to parse, and it never distinguishes this from sibling UI tools like tv_ui_record or tv_ui_anchor.

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 states a precondition ('only from its tracked origin and exact app version') and a fallback ('unknown/expired context returns a screenshot without executing'), but never says when to choose this tool over the many sibling UI tools. There is no explicit when-to-use or when-not-to-use routing.

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