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

With no annotations, the description must fully disclose behavioral traits, but it only mentions the targeting mechanism. It fails to explain behavior around tab selection, waiting, navigation side effects, or error handling—critical aspects for a browser automation tool with 8 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 extremely concise, consisting of two short sentences. Every word serves a purpose: the first states the core action, the second provides a practical use case. There is no redundancy 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?

The tool has 8 parameters, no annotations, no output schema, and the description is only one line. It lacks essential information about return values, error behavior, tab selection, waiting logic, and how the various filtering parameters interact. This is severely incomplete for a tool of this complexity.

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 explains 'selector' and 'text' implicitly, but leaves six other parameters (exact, tabId, waitMs, debugUrl, urlContains, titleContains) completely unexplained. The added semantics are minimal and insufficient for the parameter count.

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's function with a specific verb ('Click') and resource ('element'), and specifies two targeting methods (CSS selector or visible text). This distinguishes it from sibling tools like chrome_type, chrome_select, and chrome_press, which perform different 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 'Useful for control panels and file-manager buttons' gives some contextual guidance on when to apply the tool, but it does not explicitly mention alternatives or exclusions. It provides a hint of appropriate scenarios but lacks clear comparison to 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 full burden of disclosing side effects and execution context. It only says 'evaluate JavaScript' but does not state that scripts can modify the page, what the return value looks like, whether the evaluation is asynchronous, or how tab selection works. This leaves significant behavioral ambiguity for an agent invoking the 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 two short sentences, front-loaded with the core action. It provides just enough context in a compact form without extraneous detail. Each sentence adds value: the first states the primary function, the second clarifies the intended use case.

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 six parameters, no annotations, no output schema, and a complex execution environment, the description is severely under-specified. It lacks any explanation of return values, parameter semantics, tab resolution logic, or side effects. For a tool of this complexity, the description is far from adequate.

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 mentions none of the six parameters (tabId, waitMs, debugUrl, expression, urlContains, titleContains). It does not explain what 'expression' means, how tab selection is performed, or the roles of waitMs or debugUrl. The description adds no parameter-level insight beyond the schema itself.

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 evaluates JavaScript in the selected tab, using a specific verb ('Evaluate') and resource ('JavaScript in the selected tab'). It also narrows the scope to 'small, explicit inspection or panel automation snippets,' which distinguishes it from sibling tools like chrome_click or chrome_type that perform direct UI 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 description provides a clear usage context: 'Use for small, explicit inspection or panel automation snippets.' This implies when the tool is appropriate, but it does not explicitly mention alternatives or when not to use it (e.g., for complex multi-step automation). Thus it stops short of a full when/when-not breakdown.

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 full responsibility for disclosing side effects, permissions, or limitations. It only says 'extract', implying a read operation, but provides no details on whether it executes scripts, requires debugUrl, or what happens to the tab. This is a significant transparency gap.

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

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

The description is a single sentence with no redundant phrasing, making it concise and front-loaded with the core action. It efficiently lists the extraction targets. However, it is under-specified in other dimensions, but that is not a conciseness failure; it is appropriately sized for the limited information it conveys.

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 4 parameters, no output schema, and no annotations, the one-sentence description is insufficient. It does not explain return values, how filtering works, what 'candidates' means, or how debugUrl is used. The agent would lack essential context to invoke the tool correctly in non-trivial 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 0%, and the description does not mention any of the four parameters (tabId, debugUrl, urlContains, titleContains). It alludes to a 'selected Chrome tab' but does not clarify which parameter controls that selection, nor what the filter parameters do. The description fails to compensate for the schema's lack of explanations.

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

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

The description clearly identifies the tool's function: extracting media, document, iframe, and link candidates from a selected Chrome tab. It uses a specific verb ('extract') and resource ('selected Chrome tab'), and the content types listed help distinguish it from sibling tools like chrome_save_page or chrome_download_urls, though it does not explicitly compare itself to them.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites like Chrome debugging being enabled or the tab being open. The description only states what it does, leaving the agent to infer usage context 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?

With no annotations provided, the description carries the transparency burden. It discloses key behaviors: enabling DevTools Protocol and conditionally opening a new tab if Chrome is already running. However, it omits side effects, prerequisites, or failure modes such as port conflicts or behavior when extraArgs are used. The provided details are useful but minimal.

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, direct sentence that front-loads the main action. It contains no filler or redundant information, making it highly concise and appropriately structured for its 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?

The tool is complex with 6 parameters and no output schema, but the description only covers the basic launch/tab behavior. It does not explain return values, how to use the tool with respect to siblings, or edge cases like merging with an existing session. The description is too minimal for the tool's complexity, especially without annotations or schema descriptions.

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

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

The schema has 6 optional parameters with zero description coverage, and the description does not explain any of them (e.g., debugUrl, waitMs, extraArgs). Although the context hints at debugUrl via DevTools Protocol, the description fails to compensate for the lack of parameter documentation, leaving most parameters underspecified.

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

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

The description clearly identifies the tool's action: launching a Chrome window with DevTools Protocol enabled, or opening a new tab if already running. This is a specific verb+resource pair, but it does not explicitly distinguish from the sibling tool chrome_open_tab, which also opens tabs, creating some ambiguity.

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

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

The description provides clear context for when to use the tool: when you need a Chrome window with debugging enabled or want to open a tab in a running instance. However, it does not mention alternatives or when not to use it, especially given the existence of chrome_open_tab for tab opening.

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 bears the full burden of disclosing behavior. It only says 'wait briefly for the page to load,' which is vague and does not mention failure handling, return values, timeouts, or whether the tool blocks until navigation completes. This is insufficient behavioral disclosure for a navigation 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, front-loaded sentence with no redundant information. Every word contributes to the core purpose, making it concise and easily scannable.

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

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

Given the tool has 6 parameters, no output schema, and no annotations, the one-sentence description is far from complete. It omits crucial context about tab selection, debug connection, matching criteria, and expected return behavior, leaving significant gaps for the agent.

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 by explaining parameters. It only vaguely maps 'url' and 'waitMs' ('wait briefly'), leaving tabId, debugUrl, urlContains, and titleContains entirely unexplained. The agent would not know how to set these parameters or what they do.

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 ('Navigate'), the target ('the selected Chrome tab'), and the objective ('to a URL'). It also distinguishes itself from siblings like chrome_open_tab by specifying the selected tab, so the agent can tell this is for changing an existing tab's URL rather than opening a new one.

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 'selected Chrome tab' implies this tool should be used when a tab is already chosen and needs to be navigated, but it does not explicitly state when not to use it or mention alternatives like chrome_open_tab. Usage guidance is present but only implied rather than directly articulated.

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 for behavioral transparency. It discloses that the tool reuses an existing endpoint rather than launching a new browser, which is useful. However, it omits details like whether the tab is focused, what happens on failure, or whether a return value is provided. This is adequate for a simple tool but not highly transparent.

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, information-dense sentence with no unnecessary words or repetition. It efficiently conveys the core function and the key prerequisite.

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

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

The tool is simple, but the description lacks important contextual details: it doesn't state what the tool returns (e.g., tab ID, success confirmation), nor does it mention that the Chrome instance must be launched with remote debugging enabled. Given the absence of an output schema and annotations, this leaves gaps in the agent's 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 0%, so the description must compensate for parameter explanations. It doesn't mention 'url' or 'debugUrl' at all, relying on the parameter names being self-explanatory. While the names are reasonable, the description adds no value beyond the schema structure.

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: 'Open a new tab through an existing Chrome DevTools Protocol endpoint.' It specifies the verb (Open), the resource (a new tab), and the context (existing CDP endpoint). This distinguishes it from sibling tools like chrome_launch (starts a browser) and chrome_navigate (moves the current 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?

The phrase 'through an existing Chrome DevTools Protocol endpoint' provides clear context that an already-running browser is required, implying this tool should be used when such an endpoint exists. It doesn't explicitly mention alternatives or when not to use it, but the context is strong enough to guide the agent.

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

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

With no annotations, the description carries full burden. It discloses the optional focusing of an element but omits details such as how the selected page is determined (tabId, urlContains, titleContains), the effect of waitMs (default 250), and error behavior when the element or page is not found. This is insufficient for a tool with an input schema.

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 redundant wording. The key action is stated first, and the optional focusing behavior adds useful context without excess.

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 7 parameters, no output schema, and no annotations, the description is too sparse. It does not explain the selection of the target page, the reason for waitMs, or potential return/error information, so it is not complete enough for an agent to invoke with confidence.

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 only clarifies the roles of 'key' (keyboard key) and 'selector' (element to focus), while leaving tabId, waitMs, debugUrl, urlContains, and titleContains largely unexplained. The term 'selected page' hints at tab selection but does not define the 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 sends a keyboard key to the selected page, with an optional element-focus step. This uses a specific verb and resource, and the sibling list (chrome_click, chrome_type, chrome_select) shows distinct functionality, making its purpose unambiguous.

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

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

The description implies usage when you need to press a key, but does not explicitly compare with alternatives like chrome_type or chrome_click. It mentions the optional focusing behavior, giving some context, but lacks explicit when-to-use or exclusion 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?

No annotations are provided, so the description carries the full burden. It mentions the output format (PNG) but omits critical behaviors such as what 'selected page' means, how tab selection works, whether it captures full page or viewport, and what is returned (file path, etc.). The description is too vague for an agent to anticipate side effects.

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

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

The description is a single, compact sentence that is easy to parse and front-loaded. It wastes no words, but its brevity contributes to under-specification. As a concise statement, it earns a high score, though not perfect because it omits essential 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?

With 6 parameters, no annotations, and no output schema, the tool is complex enough that a full description is necessary. This description provides only a minimal declarative statement, lacking any handling of parameter relationships, default behaviors, or return values. It is fundamentally incomplete for an agent to use 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 0%, and the description provides no explanation of any of the 6 parameters. It only hints at 'selected page' without clarifying the roles of tabId, urlContains, titleContains, fullPage, or outputPath. The description entirely fails to compensate for the missing parameter documentation.

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's action: 'Capture a PNG screenshot of the selected page.' It identifies a specific verb (capture), resource (screenshot), and format (PNG). However, it does not differentiate from sibling tools like chrome_snapshot, which may also involve capturing page content.

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 offers no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It is a single declarative statement without context for 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 carries the full burden. It discloses the matching strategy but omits behavioral traits such as whether the page must be loaded, what happens if the element is not found, side effects, or return values. This is similar to the 'update_drive' example, which scored 2 for lacking such detail.

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 front-loads the verb and resource, with no unnecessary words. It is concise and easy to parse, matching the standard of the high-scoring example.

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, no output schema, and no annotations, yet the description only covers the core action and two targeting modes. It does not explain how to scope the operation to a specific tab or page, or what the wait parameter does. This leaves significant gaps for an agent to select and invoke 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 0%, so the description must compensate. It adds meaning to selector and label (the two targeting mechanisms) and hints at value semantics ('option value or visible text'), but it leaves tabId, waitMs, debugUrl, urlContains, and titleContains entirely unexplained. This is insufficient for a tool with 8 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 action ('Set a select dropdown'), the method ('by CSS selector or label text'), and the matching criterion ('matching option value or visible text'). It distinguishes this tool from siblings like chrome_click and chrome_type by specifying a select-specific operation.

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

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

The description clearly implies the usage context: when you need to programmatically select an option in a dropdown. It doesn't explicitly mention alternatives or exclusions, but the context is clear enough relative to sibling tools that it earns a 4 rather than a 3.

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

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

No annotations exist, so the description must disclose side effects, permissions, and return behavior. It does list the content captured, but omits whether the page is modified, whether it requires a loaded page, or the output format. It also does not mention the debugUrl or other operational details.

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

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

The description is a single, succinct sentence that front-loads the core action ('Summarize') and lists specific content types without fluff. It is highly concise.

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 6 parameters, no output schema, and no annotations, the description lacks detail on how to use it correctly in an automation workflow. The phrase 'selected page' is vague, and there is no mention of return structure, limits, or preconditions. The description does not cover enough for a complete 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 coverage is 0%: none of the 6 parameters are described. The description does not explain tabId, debugUrl, maxElements, etc., leaving the user without guidance on how to configure the tool. This is a significant 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?

The description clearly states the tool's function: it summarizes the selected page's visible elements (text, links, buttons, inputs, selects, forms) specifically for automation planning. This differentiates it from sibling tools like chrome_screenshot or chrome_eval.

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 during the planning phase for automation ('for automation planning'), but does not explicitly specify when to use it versus alternative tools like chrome_navigate or chrome_click, nor does it provide exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'List' implies a read-only operation, and the CDP endpoint mention provides some mechanism context, but prerequisites, potential failures, and output format are not 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?

A single, tightly crafted sentence that conveys the core functionality without any fluff or repetition. It is appropriately concise for a straightforward tool.

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

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

The tool is simple (one optional param, no output schema), but the description is minimal. It explains what is listed and the source, but lacks details about the return structure or operational requirements, making it barely adequate for reliable 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%, so the description must compensate. It indirectly references the endpoint (debugUrl) but does not explicitly explain the parameter's purpose or format, leaving the agent to infer the connection.

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 lists Chrome tabs via the local Chrome DevTools Protocol endpoint, using a specific verb ('List') and resource ('Chrome tabs'). This distinguishes it from sibling tools that perform actions like opening, navigating, or screenshotting.

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. The description does not mention prerequisites (e.g., Chrome must be running with a debug port) or any exclusions, leaving the agent to infer usage 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 disclosing behavioral traits. It states the action but does not mention side effects such as clearing the field by default (clear), submitting (submit), or waiting (waitMs), nor any failure or return behavior.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately sized for a simple purpose statement, though it lacks depth in other dimensions.

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

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

Given the tool's complexity (10 parameters, no output schema, no annotations), the description is severely incomplete. It does not explain return values, behavior of key parameters, or edge cases, making it inadequate for reliable tool 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%, so the description must compensate. It partially explains the 'selector' and 'label' parameters by mentioning locator strategies, but leaves critical parameters like 'value', 'clear', 'submit', 'waitMs', 'tabId', 'urlContains', 'titleContains', and 'debugUrl' completely 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 clearly states the tool's purpose: 'Type into an input or textarea' and lists specific locator strategies (CSS selector, label text, etc.), making the verb and resource explicit. However, it does not differentiate from sibling tools such as chrome_click or chrome_press by naming alternatives or contrasting use cases.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It only states what the tool does, leaving the agent to infer usage 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 takes on full responsibility for behavioral transparency. It discloses the return value shape and the 'fail-closed' behavior, indicating failure conditions. It does not contradict any implied behavior, and it adds useful context beyond the input schema.

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 extremely concise with only two sentences. It front-loads the core action and return format, and every word serves a purpose. There is no redundancy or 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?

Given the tool has two parameters, no output schema, and no annotations, the description covers the basic purpose and return value but lacks explanation of parameter semantics and explicit failure scenarios. It is minimally adequate but leaves gaps for an agent to infer details.

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

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

Schema description coverage is 0%, so the description must compensate. However, it does not explain the purpose or usage of either 'debugUrl' or 'urlContains'. Default values are provided but without context, the agent cannot easily understand how to set these parameters correctly.

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

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

The description clearly states the tool's action ('attach'), the resource ('already-open, already-signed-in Coinbase Advanced Trade tab'), and the behavior ('fail-closed'). It distinguishes this tool from siblings by specifying the exclusive context of an existing tab, leaving no ambiguity.

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

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

The description provides clear context for when to use the tool (attaching to an existing tab) and implies not to use it for opening new tabs. The phrase 'Never falls back to an unrelated tab' sets a boundary, but it does not explicitly mention prerequisites or alternatives, which would strengthen 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?

Despite no annotations, the description fully discloses the stub behavior: it records confirmation for audit and never arms or submits live orders, providing complete transparency about its limitations.

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?

Single sentence with zero waste, front-loaded with the key term 'Stubbed' and clear action verbs.

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 description is sufficient for a simple stub with one parameter, but it omits any indication of return value or success/error behavior, which could be useful for an agent.

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 critical constraint beyond the schema: phrase must be 'CONFIRM_LIVE_STUB_ONLY' and explains the stub's acceptance behavior, fully compensating for any lack of enum or format specification.

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 clearly states it is a stub that records a confirmation phrase for audit but never arms or submits live orders, effectively distinguishing it from real order tools like coinbase_place_order.

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?

Description implies usage only for audit recording when a stub confirmation is needed, but does not explicitly state when not to use or list alternatives. Context from sibling tools suggests real orders go elsewhere.

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?

Since no annotations are present, the description carries full responsibility for behavioral disclosure. It clearly states the tool is passive, attaches before navigation, observes multiple transport types, and writes a verdict. The explicit claim 'Never clicks or opens a Coinbase socket' adds safety assurance. However, it omits details about side effects like file creation or network activity, preventing a perfect score.

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 concise with two sentences, front-loading the core purpose. It avoids unnecessary words. However, it could benefit from a brief list of parameters or a more structured format to improve scanability.

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

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

Given the tool's complexity (observing multiple transports, writing output) and no output schema, the description fails to explain the format of the verdict or network map, the tool's lifecycle (e.g., how duration works), or how the output is stored (outputRoot parameter). This leaves significant ambiguity for the agent.

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 provides no information about the four parameters (debugUrl, durationMs, outputRoot, urlContains). The agent receives no guidance on parameter formats, defaults, or how they affect behavior, making it difficult to invoke correctly. This is a critical gap given the lack of schema descriptions.

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

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

The description clearly states it is a 'Passive transport diagnostic for Coinbase real-time data' and specifies the actions: attaches before navigation, observes transports, writes a verdict. It also explicitly distinguishes itself from interactive tools by stating 'Never clicks or opens a Coinbase socket', making its purpose highly specific and differentiated from siblings like chrome_click or coinbase_place_order.

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

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

The description implies this tool is for passive diagnostic scenarios but does not explicitly state when to use it over alternatives like coinbase_market_stream or coinbase_confirm_live. No exclusions or comparative guidance are provided, leaving the agent to infer usage context from the purpose alone.

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

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

With no annotations, the description fully discloses behavior: mirroring CDP frames, normalization types, fan-out mechanisms, sequence gap detection, and read-only nature. No contradictions.

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

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

A single sentence that is front-loaded and dense with information. Every phrase adds value; no wasted words.

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

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

The description omits what the tool returns to the caller (e.g., whether it returns a stream handle, success status, or nothing). Given no output schema, the description should clarify the invocation result. Error cases are also not mentioned.

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%, but the description adds value by implying 'durationMs' and the URL context. It doesn't explicitly describe debugUrl or urlContains, but a knowledgeable user can infer their roles. The description compensates partially.

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 specific verbs and resources: 'mirror... Coinbase WebSocket frames', 'normalize into Tick/L2Update/Trade/Candle', 'fan out to ring buffer + JSONL journal', and 'detect sequence gaps'. It clearly distinguishes from sibling tools like coinbase_place_order and portfolio 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 implies usage when needing to capture and process Coinbase market data via CDP mirroring. It states 'Read-only; opens no socket of its own', giving context. However, it lacks explicit when-to-use and when-not-to-use guidance compared to 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?

Explicitly declares 'Read-only' and enumerates returned data. Without annotations, this provides good behavioral context, though it could mention any required state (e.g., paper trading active).

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?

Single sentence concisely lists contents and states read-only nature. No wasted words, front-loaded with action verb.

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?

Description covers key return data and read-only nature. Lacks mention of prerequisites (e.g., paper mode must be running), but overall adequate for its simplicity.

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

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

No parameters exist, so description does not need to elaborate. Baseline score of 4 is appropriate for zero-parameter tool with full 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?

Description clearly states it reads the in-memory PAPER trading ledger and lists specific data: position, P&L, fills, half-Kelly sizing. It differentiates from sibling tools like coinbase_place_order (write) and coinbase_portfolio_snapshot (live).

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?

Description implies usage for paper trading status but offers no explicit guidance on when to use versus alternatives (e.g., coinbase_portfolio_snapshot). No exclusions or prerequisites mentioned.

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?

Since no annotations are provided, the description carries full burden and fully discloses behavioral traits: dryRun is hardcoded true, validates against risk limits, observe-only rejects, paper mode logs simulated fill, and never clicks the order form. No hidden behavior.

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

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

The description is concise with no redundant sentences. However, it could be structured more clearly by separating the core purpose from behavioral details. Currently it reads as a block of text.

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 lack of output schema, parameter coverage, and the complexity of the tool (8 parameters, risk validation), the description is complete for behavioral understanding but leaves a significant gap in parameter semantics, which is critical 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 does not explain any parameter's meaning or usage beyond what the schema provides. It omits details on parameters like side, type, baseSize, etc., leaving the agent to infer from schema types and enums alone.

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's purpose as a dry-run scaffold that validates orders against risk limits without ever placing a real order. It distinguishes itself from sibling tools like coinbase_confirm_live and coinbase_paper_ledger by emphasizing it never executes real trades.

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

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

The description provides explicit usage context: it is for validating would-be orders in a dry run mode and never places real orders. It implies that for actual order placement, alternative tools should be used, but does not name them explicitly.

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 burden. It mentions 'read-only' and a 'stability-ranked fallback chain' but does not detail failure modes, required permissions, or the implications of the fallback chain. Partial transparency but missing critical behavioral context.

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 concise at two sentences and front-loaded with the primary action. However, the term 'stability-ranked fallback chain' is jargon that could be simplified without losing meaning.

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

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

Given no output schema and minimal annotations, the description should provide a complete picture. It lacks details on the output format, scope of data (e.g., all accounts?), and behavior of the fallback chain. Incomplete for an agent to reliably invoke.

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 tool description adds no explanation for the two parameters (debugUrl, urlContains). The agent must rely on parameter names and defaults, which is insufficient for correct usage.

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 ('Read') and the specific resource ('balances + open orders') from a defined source ('Advanced Trade DOM'). It distinguishes itself from API-based tools by emphasizing 'never from an API', making its purpose unambiguous.

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

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

The description implies usage for real-time DOM data but does not explicitly specify when to use this tool over siblings like coinbase_market_stream or coinbase_paper_ledger. No when-not-to-use or alternative guidance is provided.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states the tool is read-only and creates local files (dom-map, network-map, behavioral.json, etc.), which is key behavioral context. It lacks some details like network usage or auth requirements, but the core safety profile is clear.

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

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

The description is two efficient sentences. The first sentence states the primary purpose, and the second details outputs and behavior (read-only). Every word adds value with no redundancy.

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

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

The description omits crucial context about parameters, making it difficult for an agent to invoke correctly without additional knowledge. It also lacks guidance on when to use this tool versus sibling reconnaissance tools like coinbase_snapshot_state. The output files are listed but no return value schema is provided, and the tool's purpose (deep reconnaissance) is clear but not fully actionable.

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

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

Schema description coverage is 0%, meaning parameters have no descriptions in the schema. The tool description does not explain any of the five parameters (debugUrl, outputRoot, urlContains, sampleSeconds, networkSeconds), leaving the agent to infer meaning from names alone. This fails to compensate for the lack of schema documentation.

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 performs deep reconnaissance of the live Advanced Trade page and specifies the output files. It distinguishes itself from sibling tools like coinbase_place_order and coinbase_portfolio_snapshot by emphasizing its read-only investigative nature.

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 mentions it is a 'one-shot' reconnaissance and 'never submits orders', implying use before trading. However, it does not explicitly state when to use this tool versus alternatives like coinbase_snapshot_state or coinbase_attach, nor does it provide exclusions or prerequisites.

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 that the tool is read-only and performs no DOM interaction, which is a key behavioral trait. However, it does not describe what the diff returns (e.g., fields that differ, errors) or any edge-case behavior, leaving gaps in transparency.

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 extremely concise at 20 words split into two focused sentences. The first sentence states the core purpose, and the second clarifies inputs and constraints. Every word adds value, and there is no extraneous 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?

Given the tool has no output schema, no annotations, and complex nested object parameters, the description is too brief. It does not explain the return value (e.g., what the diff looks like), error cases, or how to interpret results. The agent lacks sufficient information to use the tool safely and effectively.

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

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

The schema has two object parameters with 0% description coverage, so the description must compensate. It provides minimal additional meaning by labeling 'intent' as 'intended order fields' and 'preview' as 'preview-shaped object', but does not explain their structure or required fields. This is insufficient for an agent to construct valid inputs.

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

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

The description clearly states the tool performs a 'preview-vs-intent diff' for safety checks, and explicitly distinguishes itself from sibling tools by stating it performs no clicking or DOM interaction. The verb 'diff' combined with the input specification makes the purpose specific and unambiguous.

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

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

The description provides clear context for when to use the tool ('for future safety checks') and what it does not do ('no clicking or DOM interaction'), implying it should be used before action-oriented tools. However, it does not explicitly mention when not to use it or name specific alternatives, which would elevate the score to 5.

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

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

No annotations are provided, so the description carries full burden. It discloses the nature of the data (in-memory ring-buffer state) and includes counts, last tick/trade, and recent events, implying a read-only operation. However, it does not clarify side effects, whether the stream must be active, or the behavior when the buffer is empty.

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 of 20 words, front-loaded with the key purpose. Every word earns its place, and there is no redundancy.

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

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

Given the tool's simplicity (one parameter, no output schema), the description adequately covers what it does and the key parameter shape. It mentions the nature of the return data (counts, last tick/trade, recent events). However, it lacks context about dependencies (e.g., needing an active stream) and the output format.

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

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

The input schema has one parameter 'n' with no description (0% coverage). The description clarifies that 'n' controls the count of recent events, adding meaning beyond the raw schema. This is sufficient for a single parameter.

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

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

The description clearly states the verb ('Return'), the resource ('in-memory ring-buffer state'), and the context ('collected by coinbase_market_stream'). It specifies what is included (counts, last tick/trade, recent N events), which distinguishes it from sibling tools like coinbase_market_stream (which likely starts the stream) and coinbase_portfolio_snapshot (portfolio data).

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

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

No explicit guidance on when to use this tool versus alternatives like coinbase_market_stream or coinbase_portfolio_snapshot. There is no mention of prerequisites (e.g., requiring the stream to be active) or when not to use it.

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