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

The description adds value by specifying the scope ('daemon-managed browser instances and their named pages'), which goes beyond the readOnlyHint annotation. It implies a listing operation with no side effects, consistent with the annotation. However, it does not disclose the output format (e.g., whether results are flat or hierarchical), but this is acceptable for a listing tool with no output 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, concise sentence that front-loads the verb and resource. Every word earns its place, with 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 parameters, no output schema, and the readOnlyHint annotation covers safety, the description fully specifies the tool's purpose and scope. It is complete 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?

There are zero parameters and schema coverage is 100%, so the description has no need to add parameter details. The baseline of 3 applies; there is no additional meaning to add beyond what 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 uses a clear verb ('List') and specific resources ('daemon-managed browser instances and their named pages'). It unambiguously identifies the scope (daemon-managed) and the distinction between browsers and pages, which differentiates it from siblings like dev_browser_list_pages.

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

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

The description implicitly suggests use when you want an overview of browser instances, but does not explicitly state when to use this versus dev_browser_list_pages (which lists pages within a browser), nor does it provide any exclusion criteria or context about prerequisites. It is adequate but lacks explicit guidance.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It fails to state that clicking is a destructive mutation (changes page state), whether it waits for navigation, or what happens if the element is not found. The 9 parameters with complex browser/page management behavior are not explained.

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, but it combines both targeting options without clear separation. It could be improved by front-loading the primary action and then listing alternatives more explicitly. It earns its place but lacks 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 9 parameters, no annotations, and no output schema, the description should provide more behavioral context about page interaction, waiting behavior, and click effects. The existing description only covers targeting, leaving significant gaps for a tool that can change page state.

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

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

Schema description coverage is 89%, so the baseline is 3. The description adds no parameter-level details beyond what the schema provides, but does not need to significantly compensate given the high coverage. The description's mention of 'CSS selector' and 'snapshotRef' maps to the selector and snapshotRef parameters already documented in the schema.

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

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

The description clearly states the tool clicks an element, specifying two targeting methods: CSS selector or snapshotRef from dev_browser_snapshot. It provides an example ('e12'), but doesn't fully distinguish this tool from siblings like dev_browser_fill or dev_browser_type, which also interact with elements.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. With 16 sibling tools including fill, type, and evaluate, the agent has no context for choosing click over other interactive actions. No when-not-to-use or prerequisite information 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?

With no annotations, the description carries the full burden of behavioral disclosure. It adds the term 'unregister' beyond the schema, indicating that the page is removed from tracking. However, it does not disclose side effects (e.g., whether pending operations are cancelled), error conditions (e.g., closing a non-existent page), or whether the operation is synchronous. This is adequate but incomplete.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the action and resource. Every word adds value, and the structure is optimal for quick scanning by an AI 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?

Despite having 6 parameters and 15 sibling tools, the description is too brief to provide sufficient context. It does not explain the tool's role in the page lifecycle, when to use it, or what happens after closing. The schema covers parameters, but the description lacks the operational context needed for an agent to use it correctly, especially given the complexity of the tool family.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions 'named page' which corresponds to the required `name` parameter, but the schema already describes it as 'Named page to close.' The description adds no new parameter semantics beyond what the schema provides.

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

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

The description uses a specific verb-resource pair ('Close and unregister a named page') that uniquely identifies the tool's action among siblings. It clearly states what the tool does, and the verb 'close' is not used by any other sibling tool, making it 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 no guidance on when to use this tool versus alternatives like `dev_browser_list_pages` or `dev_browser_page_open`. It does not mention prerequisites (e.g., the page must be open) or scenarios where this tool is preferred. The agent is left to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full burden. It only mentions 'evaluate' without disclosing side effects (e.g., DOM mutation, global state changes), error handling, return value format, or that execution is synchronous in the page context. The phrase 'browser-side' hints at the execution context but is insufficient for a tool that runs arbitrary code.

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

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

The description is a single sentence with no wasted words, but it is also under-specified. It is not verbose, but it could be more informative without increasing length significantly. The front-loading is present (verb first), but the brevity sacrifices helpfulness.

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 7 parameters, no output schema, and no annotations, the description is too minimal. It does not explain what the tool returns (evaluated result), how promises are handled, error scenarios, or execution context details. The schema covers parameter descriptions, but the overall behavioral context is lacking for a tool executing arbitrary code.

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% (all 7 parameters have descriptions in the input schema). The tool description itself adds no additional parameter meaning beyond the schema; it merely restates the general purpose. Baseline 3 is appropriate since the schema carries the 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 verb 'Evaluate' and the resource 'JavaScript in the page', and specifies 'browser-side expression or statements'. This uniquely identifies the tool among siblings like dev_browser_click, dev_browser_fill, etc., which do not execute arbitrary JS.

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 the tool is for executing JavaScript in the page, but it does not explicitly state when to use it versus alternatives (e.g., dev_browser_click for specific actions). No when-not-to-use or exclusion criteria are mentioned; the guidance is merely implied by the verb.

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

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

With no annotations, the description carries full burden. It states the basic behavior (fills an input, replaces value) but omits details like whether the field is cleared first, what events fire, error handling (element not found, not an input), or interaction checks (visibility, scrolling). 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 compact sentences, no filler. Each word serves a purpose. Well-structured for quick reading by 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?

Tool has 10 parameters, no output schema, no annotations. The description is only 10 words long. It lacks return behavior, error conditions, prerequisites, and integration steps (e.g., need an open page). Incomplete for safe, 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 90%, so baseline is 3. The description adds minimal value beyond the schema—it clarifies that either 'selector' or 'snapshotRef' is used for targeting. No other parameter insights are provided. Does not significantly enhance understanding of 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 action (fill), the target (input), and the methods (CSS selector or snapshotRef). It also notes 'Replaces existing value,' which distinguishes it from sibling tools like dev_browser_type (which likely appends). This meets the specific verb+resource+distinction standard.

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 (e.g., dev_browser_type, dev_browser_click). No prerequisites mentioned (e.g., page must be loaded, element must exist). The description does not offer any usage context or exclusions.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It mentions 'named page' (reusing pages) and recommends a waitUntil value, but it fails to explain navigation behavior on failure, whether a new page is created if the named page does not exist, blocking semantics, side effects, or return value. This is a significant gap for a 9-parameter 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?

Two short, meaningful sentences. No redundancy or filler. The first sentence states the core purpose, and the second provides a practical tip. Efficiently uses the available space.

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 9 parameters and no output schema, yet the description is just 18 words. It does not explain the concept of 'named page,' how navigation interacts with the daemon-managed browser lifecycle, error handling, or what the tool returns. Given the complexity, the description is notably incomplete, leaving the agent without critical context.

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

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

All 9 parameters have descriptions in the input schema (100% coverage). The description adds minimal parameter-specific value beyond the schema: only the recommendation for waitUntil. This meets the baseline of 3 since schema coverage is high, but the added insight is limited.

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 'Navigate a named page to a URL,' specifying the verb (navigate) and resource (a named page to a URL). This distinguishes it from sibling tools like dev_browser_page_open (which likely opens a new page) and dev_browser_click (which may cause navigation indirectly). The purpose is 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 a concrete usage guideline: 'Prefer waitUntil=domcontentloaded for local dev servers.' This offers context-aware advice but does not explicitly contrast with alternatives or state when not to use the tool. It implies the tool is for direct navigation, which is clear from its name.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the action. It does not mention whether the tool is idempotent, requires network access, may take significant time, or what state it leaves the system in. This is insufficient for an agent to predict 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 sentence, directly front-loading the verb and resource. No extraneous words, every part earns its place.

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

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

Given the tool's simplicity (no parameters, no annotations, no output schema), the description is adequate but not complete. It does not explain the tool's role in the broader workflow (e.g., that it must be called before dev_browser_run) or any side effects. This leaves some gaps for an agent to navigate.

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

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

The tool has zero parameters and schema coverage is 100% (by default). The description adds meaning by explaining the purpose and target of the installation. While it is minimal, it is sufficient for a parameterless tool; baseline 4 is appropriate.

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

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

The description clearly states the action ('Install') and the resource ('Playwright Chromium build') with its context ('used by daemon-launched browsers'). This is distinct from all sibling tools, which focus on running, browsing, or interacting with pages.

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, whether it is a prerequisite for other tools, or under what conditions it should be called. The agent is left to infer that installation is needed before browser runs, but this is not stated.

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

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

The annotation already declares readOnlyHint: true, so the safe read nature is clear. The description adds valuable context about output format (array of objects with id, url, title, name) and mentions both named pages and tabs. No contradictions exist between description and annotations.

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. It states the action, the resource, and the output structure without any waste. Every word earns its place.

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

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

Given readOnlyHint annotation, good schema coverage, and no output schema, the description adequately covers the tool's purpose and output shape. However, it doesn't mention pagination limits, whether the list includes all frames or just main frames, or what happens when no pages exist. For a simple list tool, this is minimally complete but not thorough.

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 each of the 5 parameters is well-documented in the schema alone. The description adds no additional parameter-level insight beyond what the schema provides. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly uses the verb 'list' and resource 'named pages and open browser tabs', and gives the output structure ID, url, title, name. This distinguishes it from siblings like dev_browser_run, dev_browser_page_open, and dev_browser_snapshot. However, it does not explicitly say it returns all pages/tabs for the current browser instance, so purpose is clear but not maximally precise.

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 information about when to use this tool versus alternatives. In a large sibling set (15 tools) with many similar operations (e.g., dev_browser_page_open, dev_browser_close_page, dev_browser_snapshot), explicit guidance on when to list vs. open/close/snapshot would be valuable. There are no prerequisites, exclusions, or comparisons 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. It reveals that the tool can create a new page or reuse an existing named page, and returns url/title. However, it does not disclose side effects (e.g., whether the page is focused or brought to front), or behavior when name already exists (does it update or return existing?). For a tool with six parameters and no annotations, more behavioral details would be beneficial.

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

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

The description is a single, well-structured sentence that conveys the essential functionality with zero wasted words. It is front-loaded and easy to parse. Despite having room to add more detail, the conciseness is a strength.

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

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

Given the tool's moderate complexity (6 params, 1 required, no output schema), the description covers the core behavior (get/create/attach, return url/title) and mentions a sibling (list_pages). It lacks details about error cases, default values from schema, or how it integrates with other tools, but it is sufficient for an agent to understand the primary function.

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 100% coverage for all six parameters, so the baseline is 3. The description does not add any additional meaning or usage examples beyond what the schema already provides (e.g., relationship between 'name' and 'targetId', or when to use 'connect'). While this is acceptable, it does not exceed the baseline.

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 explicitly states the tool's purpose: to get, create, or attach to a named page or tab, returning url/title. It clearly distinguishes from siblings like list_pages (lists tabs) and close_page (closes). The verb-resource pair is specific and the three modes are well articulated.

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 usage context: it mentions using targetId from list_pages as an alternative for attaching to a tab, and implies this tool is needed before navigating or interacting with a page. However, it does not explicitly state when not to use it (e.g., if you only need a list, use list_pages) or contrast with other sibling tools like goto. Still, the guidance is clear enough for an 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 provided, the description carries the full burden. It discloses the sandbox (QuickJS vs Node.js), lists unavailable capabilities (require/import/fs/fetch/process), enumerates available globals and Page methods, explains that named pages persist, and advises on script output (console.log next-decision state). Missing details include error handling behavior, timeout consequences (though timeoutSeconds parameter exists), and session lifecycle, but overall it provides substantial behavioral context beyond a minimal description.

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 moderately long but well-structured. It opens with the core purpose, immediately gives usage prioritization, then systematically covers sandbox limitations, available APIs, page object methods, and best practices. Each sentence contributes necessary information. A slight reduction in bullet-like listing could improve conciseness, but the structure effectively front-loads critical guidance.

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

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

Given the complexity (script execution, persistent browser, no output schema), the description covers usage context, sandbox constraints, and scripting tips well. However, it does not explicitly state the return value format (e.g., does it return the console output, the script result, or an execution status?). It also omits error scenarios and default timeout behavior. While the tips partially compensate, the missing return information leaves an agent uncertain about output handling.

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 baseline is 3. The description does not add new information about the parameters themselves beyond what the schema already provides (e.g., script content, browser name, connect options, headless, timeout, HTTPS errors). The added value comes from the execution context (sandbox, APIs), which is not parameter-specific. Thus the description meets but does not exceed the baseline for parameter semantics.

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

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

The description clearly states it runs a sandboxed JavaScript script against a persistent browser. It explicitly labels itself as 'the main tool' and advises to prefer it 'whenever you need more than a single navigation/click/fill,' which distinguishes it from the long list of sibling single-action tools. The specific mention of QuickJS sandbox and available APIs solidifies its unique role.

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 explicit guidance: 'Prefer it whenever you need more than a single navigation/click/fill.' It also provides practical tips like 'Write small scripts,' 'End with console.log of the next-decision state,' and using waitUntil for local dev servers. It lacks an explicit 'when not to use' statement but the preference direction is clear enough. An explicit mention of simpler sibling alternatives would elevate it to a 5.

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

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

Annotations declare readOnlyHint=true, which is consistent with taking a screenshot. The description adds value beyond annotations by disclosing the side effect of saving a file to '~/.dev-browser/tmp/' and the return of both image and path. This informs the agent about persistent storage and output format.

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 18 words, front-loaded with the verb and resource. Every word earns its place; there is no filler or redundancy. It is optimally concise for an agent to parse quickly.

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

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

The description covers the basic purpose and output, but given the tool has 7 optional parameters and no output schema, it lacks details on error conditions, prerequisites (e.g., page must be loaded), and the exact format of the returned image (e.g., base64 or binary). It is minimally complete but not comprehensive.

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 each parameter has a description in the schema. The tool description does not add new parameter-level information beyond what is already in the schema. Baseline score of 3 applies as the description does not detract but also does not enrich parameter understanding.

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 explicitly states the action ('Take a PNG screenshot'), the resource ('a named page'), and the output ('return the image plus the saved path'). It effectively distinguishes from siblings like dev_browser_snapshot and dev_browser_goto by specifying the capture format and output 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 provides no guidance on when to use this tool versus alternatives (e.g., dev_browser_snapshot). It does not mention prerequisites (e.g., page must be open via dev_browser_goto) or when not to use it. An agent would need to infer usage from 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?

Annotations already declare readOnlyHint=true, so the description's addition of 'accessibility snapshot' and the mention of reusable refs adds some behavioral context beyond the safety profile. However, it doesn't specify what the snapshot contains (e.g., full accessibility tree, only visible elements), the return format, or any side effects like state changes. It adds moderate value but leaves 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 just two sentences, both front-loaded with the core purpose. The first sentence states what the tool returns, and the second provides a concrete usage example. There is no redundancy or filler, making it efficient for an agent to parse quickly.

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

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

Given the complexity (9 parameters, 15 siblings, no output schema), the description adequately identifies the tool's output but does not explain workflow ordering (e.g., prerequisite of having a page loaded) or the full structure of the return value. The mention of refs and getByRef partially compensates, but the lack of output schema makes the description insufficient for complete understanding of what the agent receives.

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% – all 9 parameters are individually described in the input schema. The tool description adds no parameter-specific information, so it neither enhances nor detracts from what the schema already provides. A baseline score of 3 is appropriate per guidance.

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 returns an 'AI-friendly accessibility snapshot', which identifies the verb ('Return') and resource ('accessibility snapshot'). This distinguishes it from the sibling 'screenshot' (visual) and 'evaluate' (JavaScript) tools, though it doesn't explicitly name those alternatives. The wording is specific enough to convey the tool's basic purpose.

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 usage hint ('Use refs like e12 with getByRef in a later run, or pass snapshotRef to click/fill/type'), which implies the snapshot is used for subsequent interaction. However, it offers no explicit comparison to siblings (e.g., when to use snapshot vs. evaluate or screenshot) and no prerequisites or when-not-to-use guidance. The usage context is implied but not fully directed.

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

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

The description adds the specifics of what the tool shows (status, idle timeout, managed browsers) beyond the annotation's readOnlyHint. No contradictions. It is sufficient for a simple read 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, concise sentence that conveys all necessary information without any wasted words. It is front-loaded and 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 zero parameters, a readOnly annotation, and no output schema, the description is complete. It tells the agent exactly what the tool outputs (status, idle timeout, managed browsers). No 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?

There are no parameters, and schema coverage is 100%. The description does not need to add parameter meaning; the baseline of 4 is appropriate.

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

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

The description clearly states the tool shows the dev-browser daemon status, idle timeout, and managed browsers. It uses a specific verb ('Show') and resource, and is distinct from sibling tools like dev_browser_run (start daemon) or dev_browser_browsers (list browsers).

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 the tool is for checking daemon status, but provides no explicit guidance on when to use it versus alternatives (e.g., before running other commands). No exclusions or recommendations are given.

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

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

The description explicitly states the destructive behavior ('stop the daemon', 'close every browser'), which aligns with the annotations' destructiveHint: true. It adds behavioral context beyond the annotation by specifying that all launched browsers are closed, not just the daemon process. No contradiction with annotations.

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

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

The description is a single, clear sentence that directly states the action and its effect. There is no wasted or redundant text, and every word contributes to understanding the tool's purpose.

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 parameters, no output schema, and annotations already signal destructiveness, the description captures the essential behavior. It could be slightly improved by noting whether the operation is reversible or if there are any prerequisites, but overall it is adequate for a simple stop action.

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

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

The tool has zero parameters, and the schema description coverage is 100%, so the description does not need to explain any parameters. It correctly adds no unnecessary parameter information, leaving the schema sufficient on its own.

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 ('stop', 'close') and clearly identifies the resource ('dev-browser daemon' and 'every browser it launched'). It unambiguously states the tool's action and scope, distinguishing it from siblings like dev_browser_run or dev_browser_status.

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 used when the daemon should be terminated, but provides no guidance on when to use it versus alternatives (e.g., no mention of cleanup, side effects, or prerequisites like ensuring no critical work is lost). There is no explicit when-not-to-use or alternative tool reference.

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 burden for behavioral disclosure. It only reveals the 'character by character' typing behavior, but omits critical details such as whether the tool waits for the element to appear, whether it clears existing text, what happens on timeout, or how it handles missing elements. This is insufficient for a tool with 10 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 sentence, which is concise and front-loaded with the action. However, it is so brief that it omits important context, making it under-specifying rather than efficiently complete. It earns its place but leaves gaps that could be filled with a second sentence.

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 far from complete. It does not explain prerequisites (e.g., a page must be open), interaction with the browser daemon, or how timeouts are handled. The schema provides parameter details, but the description should offer higher-level context for an agent to 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 high (90%), so the baseline is 3. The description adds value by clarifying that the element can be targeted 'by CSS selector or snapshotRef', which goes beyond the schema's individual parameter descriptions. However, it does not explain the other 8 parameters (browser, connect, headless, etc.), so the added semantic value is minimal.

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 'Type into an element' and specifies the method 'character by character', which distinguishes it from sibling tools like dev_browser_fill (which types instantly) and dev_browser_click. It also names two targeting methods (CSS selector or snapshotRef), making the tool's purpose specific and actionable.

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 like dev_browser_fill or dev_browser_click. There are no exclusions, preconditions, or context about when typing character by character is preferred. The description leaves the agent to infer usage without explicit direction.

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

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

No annotations provided, so description carries full burden. It only states the action but does not disclose timeout behavior, success/failure outcomes, whether it blocks, or what happens if the state is never reached. This is insufficient for a wait 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 sentence of 12 words, which is concise but overly brief given the tool's complexity. It sacrifices crucial behavioral details for brevity.

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

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

With 9 parameters, no output schema, and no annotations, the description is far from complete. It does not explain return values, timeout behavior, page prerequisites, or how the tool fits into the workflow.

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 89%, so the schema already documents most parameters. The description adds no parameter-specific information beyond what is in the schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool waits for a selector to reach a given state on a named page. It distinguishes from sibling tools like click, fill, or goto by implying a blocking/conditional operation, but could be more specific about the state parameter.

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

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

No guidance on when to use this tool vs alternatives, no prerequisites, and no mention of when not to use. The description is a single sentence with no usage context.

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