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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only mentions 'real input layer' without explaining side effects, focus requirements, failure behavior, or fallback mechanisms. The description does not contradict annotations (none exist), but it omits critical behavioral details for a complex interaction 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, well-structured sentence that front-loads the core action and targeting methods. There is zero wasted wording; 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?

With 11 parameters, no output schema, and no annotations, the description is far too sparse. It fails to explain when to use each targeting method, how background and domFallback affect behavior, or what the tool returns. An agent would need to infer too much to use it reliably in diverse scenarios.

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 91%, so most parameters are individually described. The description adds value by grouping the three targeting methods (uid, selector, coordinate) and implying their mutual exclusivity, but it does not explain precedence, relationships with other parameters (targetId, background, domFallback), or the purpose of maxElements. This is a baseline 3 given the high schema coverage.

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

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

The description clearly states the action (click) and the resource (Chrome), and lists three specific targeting methods (snapshot uid, CSS selector, viewport coordinate). It distinguishes from siblings like chrome_hover or chrome_tap by emphasizing 'real input layer', though it does not explicitly name alternatives.

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

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

No guidance is provided on when to prefer this tool over chrome_tap, chrome_hover, or other input tools. It also does not explain when to use uid vs selector vs coordinates, or when to set background or domFallback. Usage context is entirely implied by the description.

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 burden falls entirely on the description, which only states that Chrome pointer input is used. It does not disclose whether the drag is a single event or stepwise, how steps affect behavior, whether foreground/background execution matters, or what side effects the drag may cause on the page.

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

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

The description is a single concise sentence and communicates the core operation without unnecessary words. However, for a tool with 13 parameters, this brevity borders on underspecification rather than tight 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?

Given the high parameter count, zero required parameters, no annotations, and no output schema, the description is not complete enough for an agent to call the tool reliably. It omits critical context about required source/destination forms, coordinate space, background behavior, and result contract.

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

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

Schema description coverage is only 38%, and the description adds no meaning for most parameters. It mentions uid/selector/point and from/to, but does not explain how coordinates are interpreted, which parameter combinations are valid, how target selection works among targetId, urlIncludes, and titleIncludes, or why no parameters are 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?

The description clearly names the operation ('Drag') and the general parameters ('from one uid/selector/point to another'), which is enough to distinguish it from siblings like click, hover, and tap. It is specific about the action and the target types, though it does not explicitly differentiate itself from other tools by name.

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

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

The description gives no guidance on when to use this tool versus alternatives, no mention of prerequisites like an active Chrome tab, and no exclusions. The verb 'Drag' implies the intended use case, but the tool leaves the agent to infer all selection and targeting 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 the disclosure burden. It usefully states that execution happens in the page context and that return values must be JSON-serializable. However, it does not warn that evaluating arbitrary JavaScript can mutate the page, navigate, trigger network activity, or throw on non-serializable values.

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

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

A single front-loaded sentence that states the action, location, execution context, and return contract with no filler. Every phrase 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 6-parameter arbitrary-JS execution tool with no annotations and no output schema, this is too sparse. It does not cover error behavior, side-effect risks, how targetId/urlIncludes/titleIncludes interact, or what happens for non-serializable results.

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

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

Schema description coverage is 83%, so the schema already documents most parameters. The description adds context for the required 'expression' parameter by framing it as JavaScript that returns serializable values, but it does not add meaning for target selection or background/awaitPromise beyond the schema.

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

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

The description names a specific verb ('Evaluate JavaScript'), the resource ('an existing Chrome tab'), and the result type ('JSON-serializable values'), making the core purpose unmistakable. It does not explicitly name or contrast sibling tools, but 'evaluate' is distinct from navigation/click/snapshot siblings.

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

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

The phrase 'existing Chrome tab' implies the prerequisite that chrome_launch/chrome_tab must be used first and that this is for running code rather than inspecting or acting on the page. It provides no explicit when-to-use or when-not-to-use guidance and names no 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 are provided, so the description carries the full burden. It discloses that the tool uses click/select/delete/type input, which suggests it may simulate user interaction, but it does not disclose behavior like whether it clears existing value, whether it waits for elements, or whether it handles contenteditable differently. It also mentions 'Chrome' in the description, implying it requires Chrome. However, the 'click/select/delete/type' sequence is a useful behavioral hint beyond the schema, but it lacks details on side effects such as focus changes or potential for overwriting.

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

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

The description is a single sentence that is concise and front-loaded with the core purpose. It doesn't waste words, but it could be more structured by adding a second sentence for usage guidance. Given the tool's complexity (12 parameters), a slightly longer description would be warranted, but as is, it's efficient.

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

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

Given the high complexity (12 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain how to target the element (which parameters to use), what happens with the submit flag, or how background vs foreground affects behavior. An agent would struggle to know which parameters are required for which scenarios. The description leaves too much to inference. It should at least hint at usage patterns.

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 42%, meaning many parameters lack descriptions. The description itself adds no parameter-specific semantics; it doesn't mention 'uid', 'selector', 'targetId', 'domFallback', 'maxElements', etc. However, some parameters have schema descriptions (submit, targetId, background, urlIncludes, titleIncludes). With 42% coverage, the description should compensate for the undocumented parameters, but it does not. Thus, it's below baseline 3 for compensation, but given the baseline of 3 for high coverage is not met, this is a gap. Score 3 is generous because the schema covers some key ones.

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

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

The description states a specific verb ('set') and resource ('text input, textarea, or contenteditable'), and mentions the mechanism ('using Chrome click/select/delete/type input'), which implies a multi-step interaction. This is somewhat clear but could be more precise about what 'full value' means in context and how it differs from chrome_type (which might append or type incrementally). The siblings include chrome_type, chrome_click, and chrome_find, so the description helps distinguish from chrome_type but not as explicitly as it could.

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

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

The description does not provide any guidance on when to use this tool versus its siblings. For example, it doesn't say 'use this to replace the entire input value, whereas chrome_type appends text.' Given the presence of chrome_type and chrome_click, explicit distinction would be helpful for an agent deciding between these tools. The description only states what it does, not when to prefer it over alternatives.

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

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

With no annotations, the description carries the full burden. It does disclose that results are ranked and include stable uids and coordinates, and that the scope is the current Chrome page. However, it is silent on potential side effects, focus behavior, failure modes, or how ranking works, leaving notable gaps.

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

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

Two tight sentences with no filler. The action is front-loaded and the output details are given immediately. Every word contributes.

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?

Despite the clear summary, this tool has seven parameters, no output schema, and no annotations. The description does not explain the mode enum, the meaning of 'ranked matches' in practical terms, or how the returned uids/coordinates are meant to be consumed by sibling tools like chrome_click. More detail is needed for an agent to use it 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 coverage is 71%, so several parameters already have descriptions. The description adds little beyond the query concept; it does not explain mode options, maxElements, or how targetId/urlIncludes/titleIncludes affect the search. The term 'current Chrome page' could even conflict with the ability to target other tabs via targetId, adding ambiguity.

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

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

The description uses a specific verb 'Find' and resource 'matching controls/text/regions on the current Chrome page', and clearly states the output: ranked matches with stable uids and coordinates. This makes the tool's role obvious, though it does not explicitly differentiate from sibling tools like chrome_inspect or chrome_snapshot.

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

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

No guidance is given about when to use this tool versus alternatives. There is no mention of typical workflows (e.g., find before click), no exclusions, and no reference to sibling tools. The description only states what it does, not when to choose it.

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 disclose behavior itself. It conveys that the entry must already be captured and that the response body may be absent, but it does not explain what happens for missing request IDs, tab targeting, or what fields the returned entry contains.

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

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

The description is a single concise sentence with the main purpose front-loaded and no filler. It could add a usage pointer, but the format is efficient.

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-entry retrieval with fully documented parameters, the description covers the core task and caveat, but with no output schema and no annotations it leaves the return shape and error behavior undocumented. This is adequate but not 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 coverage is 100%, so the baseline applies; the schema already explains requestId, targetId, urlIncludes, and titleIncludes. The description adds no parameter-level detail beyond the schema, which is acceptable at this coverage level.

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 object: 'Retrieve one captured fetch/XMLHttpRequest entry'. The 'one' and 'requestId' parameter make it distinct from the plural chrome_list_network_requests sibling, though it does not explicitly name that 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?

The requestId schema description ties this to chrome_list_network_requests, implying a list-then-get workflow, but the tool description itself gives no explicit when-to-use or when-not-to-use guidance. The 'when available' caveat hints at limitations but not 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?

With no annotations, the description carries the burden of behavioral disclosure. It mentions 'Chrome pointer movement,' which is useful, but it does not disclose side effects like triggering hover events, whether the pointer actually moves, focusing behavior, or what happens if the target is not found.

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

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

The description is a single front-loaded sentence with no filler. Every phrase adds meaning: the action, the target, the locator modes, and the mechanism.

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 8 parameters, no annotations, no output schema, and only 50% schema coverage, the description leaves too much unstated. An agent still needs to infer target tab selection, default background behavior, and what a successful hover returns or signals.

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 50%, and the description partially compensates by explaining that uid, selector, and x/y are alternative targeting mechanisms. However, it does not clarify whether one is required, whether they are mutually exclusive, or how they interact with targetId/urlIncludes/titleIncludes.

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

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

The description uses a specific verb ('hover over') and resource ('element'), and clearly states the three supported input mechanisms: uid, selector, and x/y. It is unambiguous and distinct from sibling tools like chrome_click and chrome_type.

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

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

The description does not say when to prefer hover over click, tap, or other interactions, nor does it state any exclusions or alternatives. It tells what the tool does, but not when it should be used in relation to its 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 carries the behavioral disclosure burden. It discloses the kind of output expected by enumerating nearby text, actions, form context, ancestors, and suggested click target. It does not explicitly state that the operation is read-only or describe side effects like focusing or activating the tab, though 'Inspect' implies a non-mutating 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?

The description is a single informative sentence with no filler. The list of deep-context outputs adds value and is front-loaded; it does not repeat schema details or annotations.

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

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

For a tool with no output schema and no annotations, the description provides the essential output categories and the schema fully documents parameters. Still, some invocation context is missing, such as read-only guarantees, tab-selection priority, or how the suggested click target is derived, leaving moderate 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%, so all seven parameters are already documented. The tool description adds little parameter-level meaning; it only reinforces that a uid or selector is the inspection target, which the schema already conveys.

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 ('Inspect'), a specific resource ('one snapshot uid or selector'), and lists the deep context it returns: nearby text, nearby actions, form context, ancestors, and suggested click target. It does not explicitly name or differentiate from sibling tools, though the 'deeply' clause separates it from tools like chrome_snapshot and chrome_find.

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: when you have a specific uid or selector and need deep contextual information about that element. However, it does not explicitly state when not to use it or mention alternative tools such as chrome_snapshot/chrome_find for lightly inspecting elements.

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 states the action but does not mention tab activation/focus behavior, whether it waits for page load, or what happens on invalid keys. The background parameter behavior is only in the schema, not the description, leaving significant behavioral gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose and allowed inputs. No waste, and it avoids redundant details.

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 8 parameters including nested modifiers and multiple targeting methods, but the description provides no guidance on how to target a tab (targetId vs urlIncludes vs titleIncludes), modifier usage, background behavior, or snapshot inclusion. Without an output schema or annotations, this is notably incomplete 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 description adds almost no parameter meaning beyond the schema. It only lists allowed key values; it does not explain targetId, modifiers, background, maxElements, or includeSnapshot. With 63% schema coverage, the description should compensate for undocumented parameters but does not.

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

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

The description clearly states the action (send a keyboard key), the target (existing Chrome tab), and the specific allowed keys (Enter, Escape, Tab, etc., or one character). This is specific and distinguishes it from siblings like chrome_click or chrome_type.

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

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

The description implies usage for sending single keys or key combinations, but does not explicitly compare to alternatives like chrome_type (typing text) or chrome_fill. No when-to-use or when-not-to-use guidance is provided, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions checking a bridge and opening a URL in an existing profile, but does not clarify whether Chrome is actually launched, what 'connecting' involves, what side effects occur, or what errors or return values to expect.

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 brief and front-loads the core 'check the bridge' behavior. The phrasing 'With url' is awkward, but overall it is appropriately sized and avoids unnecessary detail.

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

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

There is no output schema and no annotations, so the description must provide enough context for an agent to invoke this safely and correctly. It does not explain what the local bridge is, what successful execution looks like, when to call this tool relative to the other chrome_* tools, or what the connection step entails.

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 optional url parameter. The description adds a small amount of meaning by saying the url opens in the existing profile after connecting, but it does not elaborate on URL format, behavior when omitted, or failure modes.

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 resource ('local bridge') and a behavior ('check', then optionally 'opens it'), but 'local bridge' is vague and the connection to the tool name 'launch' is unclear. It does not meaningfully distinguish this from sibling tools like chrome_navigate or chrome_tab.

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

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

There is no guidance on when to use this tool instead of alternatives. The only contextual hint is 'after connecting', which implies sequencing but does not explain prerequisites, whether this should be called first, or when a sibling such as chrome_navigate would be more appropriate.

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

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

With no annotations, the description carries the full burden. It only states that messages are listed, but fails to disclose that the clear parameter can wipe the log after reading, or any read-only guarantees. This is a minimal disclosure of behavior beyond the basic function.

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

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

A single, front-loaded sentence that communicates the core purpose without verbosity. However, it is almost too sparse, omitting relevant behavioral and targeting information, though it remains structurally efficient.

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 no annotations and no output schema, the description is insufficiently complete. It omits any mention of tab targeting behavior, the clear parameter's side effect, or the format of the returned messages. An agent would lack context to use it correctly beyond a basic understanding.

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 parameters are fully documented in the schema. The description adds no extra meaning or context about parameter usage, such as how targeting works or the effect of clear. Baseline 3 applies because the schema handles the 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 clearly states the action (list) and resource (console messages) and mentions the source (captured by companion extension). It is distinct from siblings like chrome_list_network_requests because it focuses on console messages, though it does not explicitly name alternatives.

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

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

No guidance is provided on when to use this tool versus alternatives such as chrome_inspect or chrome_list_network_requests. There is no mention of use cases, prerequisites, or conditions that would select this tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that it lists captured activity; it does not reveal whether it returns a plain list, whether it includes preserved requests across navigations, whether the 'clear' option has side effects, or any other behavioral traits. This is a significant gap for a tool with side-effect-capable parameters.

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

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

The description is a single, front-loaded sentence that identifies the tool's core function with no wasted words. However, it is perhaps too sparse given the complexity of the parameters, so it doesn't earn a 5.

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

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

The tool has 5 optional parameters, no output schema, and no annotations, so the description must provide substantial context. It lacks any mention of return format, extension prerequisites, tab-selection semantics, or the effect of the 'clear' parameter. An agent calling this tool would be uncertain about what it returns and how it behaves under different parameter combinations.

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 every parameter has a description. The tool description itself adds no parameter-level meaning beyond what the schema provides. Per the rubric, the baseline is 3 when coverage is high, and the description neither enhances nor contradicts 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 clear action ('List') and resource ('fetch/XMLHttpRequest activity'), and mentions the companion extension as the capture source. It doesn't explicitly contrast with the sibling chrome_get_network_request, but the verb 'list' implies a collection rather than a single item, which provides some 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 guidance is given about when to use this tool versus alternatives like chrome_get_network_request, chrome_list_console_messages, or even when the companion extension is required. There are no usage contexts, selection criteria, or explicit exclusions, leaving the agent to infer when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden. It discloses a critical behavioral trait: navigation targets a dedicated automation tab by default and never replaces the user's active tab. It does not mention side effects like history changes or whether the tab is brought to foreground, but the disclosed default-target behavior is significant and useful.

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 no filler. The first sentence states the action, the second clarifies the default target and a critical safety property. 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 navigation tool with 8 parameters and no output schema, the description is concise but covers the most important context: default target and non-disruption of the user's tab. It does not explain return values or failure modes, but the schema covers parameters well and the tool's behavior is relatively straightforward.

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 88%, so the schema already documents most parameters. The description adds the key semantic that 'no target' means the dedicated automation tab, which clarifies the optional targetId and urlIncludes/titleIncludes matching behavior. However, it does not explain how targetId interacts with urlIncludes/titleIncludes or the exact meaning of 'background' beyond the schema.

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

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

The description states a specific verb ('Navigate') and resource ('a Chrome tab to a URL'), and immediately distinguishes its default behavior from the user's active tab. This clearly separates it from sibling tools like chrome_launch, chrome_tab, and chrome_snapshot.

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 the default target (dedicated automation tab) and explicitly notes it never replaces the user's active tab, which is key usage context. It does not explicitly name alternative tools for other navigation scenarios, but the default behavior is clear enough for an agent to decide when to use it.

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 transparency burden and does disclose one meaningful side-effect guarantee: background tabs are not activated. It also clarifies that the artifact is written to disk. It does not address outcomes like return values, default target selection when no targetId/selectors are given, or failure modes, but the disclosed behaviors are accurate and useful.

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 front-loads the action and outcome and contains no filler. Every phrase (CDP, save to disk, no background activation) carries information.

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

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

Despite a rich schema, the overall definition fails to explain what happens when none of targetId/urlIncludes/titleIncludes are provided, whether a launched Chrome is assumed, or what the tool returns after saving. The added 'without activating background tabs' helps, but for a tool with 8 optional parameters and no output schema or annotations the description is not complete enough.

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 high (88%), so the parameters are already well documented and the baseline is 3. The description adds modest context by explaining why the background behavior matters, but it does not elaborate on path, format, fullPage, or target matching beyond the schema.

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

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

The description names a specific action ('Capture a screenshot'), a resource ('of a Chrome tab'), a mechanism ('via CDP'), and an output ('save it to disk'), so the core purpose is unmistakable. It also states a distinguishing behavior ('without activating background tabs'). It does not explicitly differentiate from the similarly named sibling chrome_snapshot, so it stops short of a 5.

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

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

The phrase 'without activating background tabs' communicates a useful use case: screenshotting without disturbing tab focus. However, the description never states when to choose this over chrome_snapshot or what prerequisites are needed (e.g., a launched Chrome session), and it gives no exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that it dispatches real wheel events with momentum-shaped deltas, which is useful behavioral context. However, it does not mention side effects like focus changes, whether the scroll is smooth or instant, or what happens if the selector is invalid. The description adds some value but leaves significant behavioral gaps.

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

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

The description is a single, focused sentence that front-loads the core action and mechanism. It is concise and avoids redundancy with the schema. It could be slightly more informative about usage context, but it earns its place as an efficient definition.

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

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

Given the tool has 9 parameters, no annotations, and no output schema, the description is somewhat thin. It explains the core mechanism but does not cover target selection (uid, selector, targetId, urlIncludes, titleIncludes), the meaning of 'steps', or the 'background' behavior. An agent would need to infer or inspect the schema to understand how to target the scroll. The description is adequate for a simple scroll but incomplete for a tool with this many parameters.

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 78%, so the schema already documents most parameters. The description adds the momentum-shaped delta behavior, which gives meaning to deltaX/deltaY, but it does not explain the 'uid' or 'selector' parameters beyond what the schema provides. The description adds marginal value over the schema but does not fully compensate for the undocumented parameters.

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

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

The description clearly states the tool scrolls the page or a specific scrollable element by dispatching real wheel events with momentum-shaped deltas. It uses a specific verb ('scroll'), names the resource ('page or a specific scrollable element'), and distinguishes the mechanism ('real wheel events with momentum-shaped deltas') from other navigation or interaction tools.

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

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

The description implies usage for scrolling, but does not explicitly state when to use this tool versus alternatives like chrome_evaluate (for programmatic scroll) or chrome_drag (for drag-based scrolling). It does not mention exclusions or prerequisites, such as needing a target tab or element. The context is clear but the guidance is not explicit.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It reveals useful output traits (agent-friendly observation, stable uids, page hints) and implies a read-only snapshot operation, but it does not explain side effects, target-tab resolution, default behavior, or failure modes. This is adequate but not rich.

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

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

Two sentences deliver purpose, output characteristics, and usage guidance with no filler. The key distinction about zooming is front-loaded and directly actionable. 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 an 11-parameter tool with no output schema and no annotations, the description is brief but provides a decent high-level framing. The rich per-parameter schema descriptions compensate for many details, but the description does not cover default snapshot behavior, tab-selection strategy, or how this tool relates to nearby Chrome inspection siblings. It is minimally adequate with clear 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 high at 91%, establishing a baseline of 3. The description adds meaning beyond the schema by explicitly grouping mode/query/nearUid as a zoom mechanism rather than a full-page dump. This gives the agent a useful semantic hint for parameter selection beyond what each schema field already states.

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

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

Description states a specific verb and resource: 'Inspect a page in the existing Chrome profile.' It also clarifies what the tool returns—stable uids, visible actions, form fields, and page hints—which gives the agent a concrete idea of the tool's output. It does not explicitly differentiate itself from nearby siblings like chrome_inspect or chrome_find, so it stops short of a 5.

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

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

The description gives clear context: this tool inspects pages in an existing Chrome profile, and instructs to use mode/query/nearUid to zoom rather than dumping the full page. It provides actionable within-tool guidance but does not name alternative tools or state when to prefer one over another, so it lacks explicit sibling selection guidance.

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

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

With no annotations, the description carries the full burden. It discloses non-obvious behavior: new/grouped tabs join this session's tab group, and target-less actions affect the automation tab. This is meaningful beyond the schema, though it remains silent on return shapes and whether close is irreversible.

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 with no wasted words. It front-loads the action list, then appends the two most important behavioral clarifications in a compact way.

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 seven parameters, an enum of varied actions, and no output schema. The description omits return-value semantics for informational actions like list, inspect, and version, and does not clarify what 'new' does when url is absent. These gaps matter for an agent selecting and invoking the tool correctly.

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

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

Schema description coverage is 86%, so the baseline is 3. The description adds targeting context (targetId/urlIncludes/titleIncludes) and the no-target fallback, but it does not add substantive detail about parameter interactions beyond what the schema already encodes.

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 enumerates a precise set of verbs ('List, create, activate, close, group, ungroup, or inspect') applied to a specific resource (tabs in the user's existing Chrome profile). This distinguishes it clearly from sibling tools like chrome_launch, chrome_navigate, or chrome_inspect.

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 explains the key targeting rule: activate/close/group/ungroup require a target, and if none is supplied they fall back to the session's automation tab. This gives clear context for choosing call patterns, though it does not explicitly contrast with sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It usefully reveals that the tap is a real touch event rather than a synthetic click, and that it is intended for TouchEvent-gated pages. However, it does not disclose side effects, focus/tab activation behavior, or what happens when targeting via selector vs coordinates.

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 focused sentences with no wasted words. The core action is front-loaded and the key use case follows immediately, making it quickly scannable for an agent.

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 8 parameters, no annotations, and no output schema, the description is too sparse. It omits essential context around coordinate semantics, selector vs x/y, target tab targeting, and return behavior, leaving an agent under-equipped to invoke the tool reliably.

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

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

Schema description coverage is only 50%, and the description adds no parameter-level meaning. Parameters like x, y, uid, and selector are left undocumented in both the schema and the description. The description does not compensate for the low coverage.

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: 'Dispatch a real touchstart/touchend tap through Chrome's input layer.' It also names the differentiating use case ('sites that gate on TouchEvent'), which separates it from siblings like chrome_click and chrome_click-like actions.

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 'Use for sites that gate on TouchEvent' provides a clear, explicit condition for when to select this tool. It does not mention alternatives or when not to use it, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully reveals that typing uses Chrome's real input and that perCharacter sends individual keydown events, but it does not mention tab activation, background behavior, return values, or what happens when no selector/uid is provided.

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 no filler: the first front-loads the action and target, the second gives focused parameter guidance. 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 an 11-parameter tool with no annotations and no output schema, the description is too sparse. It omits targeting semantics, snapshot behavior, operational side effects, and return expectations, leaving an agent with significant 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 only 45%, so the description should compensate for the remaining parameters. It adds meaning for uid, selector, and perCharacter, but leaves text, pressEnter, maxElements, includeSnapshot, and several targeting parameters 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?

The description states a clear action: focus an optional snapshot uid or CSS selector, then type via Chrome's real input. It identifies the resource and core behavior, though it does not explicitly distinguish itself from sibling tools like chrome_fill or chrome_key.

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

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

No guidance is given for when to use this tool versus alternatives. The only conditional advice, 'Set perCharacter=true for editors needing individual keydown events,' addresses a parameter setting rather than tool selection.

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 itself must carry behavioral disclosure. It usefully states that the native file picker is not opened and that the Chrome DevTools file-input control is used, but it omits side effects, tab-focus behavior, and failure modes.

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 no filler. The core action is front-loaded, and the important negative behavior ('Does NOT open the native file picker') is stated immediately after the action.

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 7-parameter tool with no annotations and no output schema, the description is too sparse. It does not explain how target tabs are resolved, what background mode means in practice, or what the tool returns or throws when invocation fails.

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 71%, so most parameters (paths, targetId, background, urlIncludes, titleIncludes) already have schema-level descriptions. The description adds the contextual idea of local files and a file-input element, but does not clarify the undocumented uid or selector fields.

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

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

The description opens with a specific action ('Attach local files to an <input type=file> element using Chrome DevTools file-input control') and clearly distinguishes this from sibling interaction tools like chrome_click and chrome_type. It leaves no doubt about what the tool does and how it differs from opening the native picker.

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 a clear usage context: attaching local files to a file input, while explicitly ruling out native-picker automation. It does not name alternative tools or when-not conditions, but it gives enough for an agent to route to this tool 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?

With no annotations present, the description must carry the behavioral disclosure burden. It reveals that the tool polls and targets existing tabs, but omits what happens on timeout, whether it returns a result or just success, and how tab selection works when multiple selectors are given. These are significant gaps for a polling 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?

The description is an efficient single sentence with zero filler and front-loads the core behavior (polling) before the conditions. It is easy to parse and immediately actionable.

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 7-parameter tool with no annotations and no output schema, the description leaves out important runtime context such as failure behavior, return value, and how timeout/interval defaults. It is minimally viable but not complete enough for an agent to anticipate edge cases.

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

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

Schema description coverage is high (86%), so a baseline of 3 is appropriate. The description adds a little value by clarifying that kind=expression means truthiness evaluation, but it does not meaningfully compensate for the undocumented target-matching params.

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?

Uses a specific verb ('Poll') and resource ('existing Chrome tab'), and clearly defines the terminating condition — a selector existing or a JavaScript expression returning truthy. This strongly distinguishes it from sibling tools like chrome_find and chrome_evaluate, which are about inspecting snapshots or evaluating expressions 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?

The description implies when to use the tool: you need to wait until a condition becomes true in an already-open tab. However, it never explicitly says when not to use it or which sibling tools should be preferred for direct inspection versus waiting.

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