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

With no annotations, the description carries the behavioral disclosure burden. It reveals the implementation approach ('rule-based DOM heuristics — no LLM dependency'), which is useful, but omits caveats about failure modes, side effects of actions, or whether actions are irreversible. This leaves the agent with incomplete safety awareness.

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 reasonably sized but contains promotional fluff ('GROUNDBREAKING', 'One tool call does what normally takes 5-10') that does not add operational value. The examples are useful but could be trimmed. Front-loaded enough, but not every sentence earns its place.

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

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

The tool has a single parameter, no output schema, and no annotations. The description explains the interaction model and lists varied examples, giving a general sense of capability. However, it does not mention return values, error handling, or limitations (e.g., unsupported page states), which is needed for reliable use in complex browser automation contexts.

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% with one instruction parameter, so baseline is 3. The description adds value through concrete examples of acceptable instructions, clarifying the natural language format and range of intents beyond the schema's minimal description.

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?

Clearly states it performs natural language page interaction, a distinct capability from sibling tools like browser_click, browser_fill, and browser_goto. The examples ('search for laptops under $1000', 'click the login button', 'fill email') concretely illustrate the scope.

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?

Implies use as a higher-level alternative to multiple discrete tool calls ('One tool call does what normally takes 5-10'). Provides examples across navigation, clicking, filling, extraction, and scrolling, which signal when it applies, but does not explicitly say when to prefer sibling tools like browser_eval or browser_waitForSelector.

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 the burden. It analogizes to a browser back button, which conveys typical behavior but does not specify effects if there is no history, or whether it waits for page load. It is adequate but not detailed.

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

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

The description is a single, front-loaded sentence that directly conveys the purpose with no extraneous words. 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 the tool has no parameters, no output schema, and no annotations, the description is largely complete for the action. It could mention additional behavioral details (e.g., no history leads to no action), but the current description is sufficient for a simple navigation tool.

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

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

The input schema has no parameters, so the description does not need to supplement parameter information. The analogy adds context beyond the empty schema, making the action clear. With 0 parameters, the baseline is 4.

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: 'Go back in browser history (like clicking the browser back button).' It uses a specific verb and resource, and the analogy distinguishes it from sibling tools like browser_goto or browser_click.

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 use case (navigating back in history) but does not explicitly state when to use it or when not to, nor does it mention alternatives or conditions like requiring a history entry. It is minimal but adequate for a simple action.

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 mentions using CDP Input.dispatchMouseEvent for native events, but does not disclose other important behaviors such as scrolling into view, waiting for element, or error handling. Since annotations are absent, more transparency is needed.

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, no redundant information, and front-loads the main 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 simplicity of a click action and no output schema, the description is somewhat complete but lacks details on return value, error scenarios, and coordinate behavior.

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 sole parameter 'selector' is fully described in the schema with 'CSS selector'. The tool description adds no extra meaning beyond that, so baseline score 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 clicks an element by CSS selector, using a specific verb and resource. It distinguishes from sibling tools like browser_goto, browser_fill, and browser_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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, scenarios, or exclusions.

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

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

With no annotations provided, the description must carry the behavioral burden. It discloses the default behavior, the limitation on closing the last tab, and the suggested alternative. Could be slightly richer (e.g., what happens to page state), but it is largely transparent for a simple close action.

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

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

Two short sentences deliver the core action, default, and a key exception. Every word earns its place; no redundancy or fluff.

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 with one optional parameter and no output schema. The description covers the action, default, and edge case, and provides an alternative for the one forbidden scenario. It is fully self-contained for the given 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?

The schema already provides 100% coverage for the single parameter, including the optional default behavior. The description adds no new parameter-specific meaning beyond what the schema states, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Close a browser tab'), the target ('by targetId'), and the default behavior when no ID is given. It distinguishes itself from sibling tools like browser_restart and browser_newTab by specifying exactly what it does.

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

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

Explicitly explains the default behavior (closes active tab if no targetId) and provides an exclusion: cannot close the last tab, directing the user to 'browser_restart' as an alternative. This is precise when-to-use 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 what the tool returns but not whether it is read-only, whether it executes scripts, or any potential side effects like modifying page state or requiring network requests. The absence of safety and side-effect disclosure is a significant gap for a diagnostic tool that could be heavy.

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 sentences, front-loaded with the core purpose and immediately informative. The first sentence gives a crisp summary, the second adds a helpful analogy. No waste or redundancy, making it exceptionally 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?

The tool is complex with multiple return types and no output schema. The description enumerates key return categories (performance metrics, console errors, broken images, meta tags, health score), which is a solid summary. However, it lacks details on how the health score is defined or any prerequisites (e.g., requiring a loaded page), leaving some gaps given the richness of the tool.

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

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

The input schema has zero parameters and 100% schema description coverage (empty). With no parameters to explain, the description adds no parameter-specific value, but the baseline 4 applies because there is nothing missing in that regard.

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 does a 'Full page health diagnostic' and lists specific outputs (performance metrics, console errors, broken images, meta tags, health score). This distinguishes it from sibling tools like browser_text or browser_html, which are focused on content retrieval rather than health assessment.

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 the analogy 'Like Lighthouse for your agent' which suggests a comprehensive audit use case, but it does not explicitly state when to use this tool versus alternatives (e.g., using browser_title for a quick check). There are no exclusions or direct comparisons to siblings, leaving usage guidance implied rather than explicit.

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

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

With no annotations, the description carries the full burden and does a good job exposing non-obvious behavior: it requires yt-dlp, returns install instructions instead of failing silently if it is missing, and never performs silent installs. It does not describe return values or file effects, but the most surprising behavioral traits are 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?

The description is two efficient sentences: the primary action is front-loaded and the dependency caveat follows immediately. There is no filler, duplication of schema fields, 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 three parameters, no annotations, and no output schema, the description covers the main invocation concern: the external dependency and what happens when it is absent. It does not specify the return value or the download destination, but an agent can still select and call the tool correctly from the schema plus this 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?

Schema coverage is 100% and each parameter already has clear descriptions and enums. The description adds little semantic value beyond restating the artifact types that already appear in the format enum, so the baseline score of 3 is appropriate.

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

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

The description names a specific verb and resource: 'Download media from a URL' with the artifact types enumerated (video, audio, subtitles, thumbnail). This clearly differentiates it from the sibling browser_* tools that deal with navigation, clicking, screenshots, or 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 intended use is implied clearly: use this when you need to download media from a URL. However, it does not explicitly say when to prefer this tool over a sibling or when not to use it, and the yt-dlp requirement reads as a prerequisite rather than comparative usage routing.

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

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

With no annotations, the description must disclose behavior. It only says 'list' but does not clarify if elements must be visible, what happens if none match, or any side effects. Minimal 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 a single concise sentence that clearly conveys the purpose. However, it could be more structured (e.g., listing return type) without losing conciseness.

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

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

For a tool that returns a list of elements, the description lacks details about the output format, attributes returned, or any filtering behavior. Given no output schema, more information is needed for full completeness.

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

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

Schema coverage is 100% and the parameter has an enum with descriptions. The description echoes the enum values, adding no new meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states exactly what the tool does: list interactive elements by kind, specifying the four kinds (links, buttons, inputs, headings). It uses a specific verb 'list' and distinct resource 'interactive elements', clearly differentiating from sibling tools like browser_click or browser_goto.

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 usage guidelines are provided. The description does not inform the agent when to use this tool (e.g., before interacting with page) or when not to (e.g., if only text needed). No alternatives are 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?

With no annotations, the description must disclose behavioral traits, but it only states 'execute JavaScript'. It fails to mention whether the execution is synchronous, what happens to return values, security implications, or potential side effects (e.g., DOM modifications). This is insufficient for safe and effective use.

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 (one sentence), but conciseness comes at the cost of informativeness. It is front-loaded and efficient, yet it sacrifices necessary detail, earning a middle score.

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 potential for arbitrary execution (no output schema, no annotations), the description is incomplete. It omits return behavior, error handling, and scope of execution. The single parameter is documented only minimally, leaving critical gaps for an AI 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 coverage is 100%, and the description adds no extra meaning beyond the schema's 'JavaScript expression' description. The value conveyed is identical, so it meets the baseline of 3 for high coverage without adding new insight.

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 action (execute JavaScript) and the context (page context), distinguishing it from sibling tools like browser_click or browser_goto which perform specific UI actions. However, it lacks specificity about the execution environment or return value, making it slightly less than exemplary.

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 (e.g., browser_watch or other interaction tools). There are no prerequisites, exclusions, or context hints, leaving the agent to infer appropriate usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It transparently states dependency behavior, the return of install instructions on missing libraries, and the 'no silent installs' policy. It omits details like success return value or overwrite behavior, but the core side effects and failure paths are well covered.

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

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

The description is a tight two-sentence structure. The first sentence front-loads the primary purpose ('Export findings/text to a file'), and the second delivers dependency and policy information. Every word earns its place, with no filler or repetition of schema fields.

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 a simple four-parameter schema and no output schema, the description covers the critical nuance: which formats work out of the box and what happens when dependencies are missing. It does not describe the success return value (e.g., written file path), but an agent can reasonably infer the action's outcome. The main missing piece is a note on whether an existing output file is overwritten.

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 already covers all four parameters with 100% description coverage, so the baseline is 3. The description adds meaningful extra context by clarifying format-specific dependencies (md/txt/html vs docx/pdf/pptx), which is not present in the format property's schema description. This helps the agent understand why certain enum values may trigger install instructions.

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 starts with a clear verb and resource: 'Export findings/text to a file.' It also lists supported formatscars, which adds specificity. However, it does not explicitly distinguish itself from the sibling tool browser_download, leaving the agent to infer that 'export' means writing provided content to a file rather than downloading from a webpage.

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 actionable dependency guidance: md/txt/html always work, while docx/pdf/pptx need python libs and fall back to install instructions. It also states a clear policy ('No silent installs'). It does not name alternatives or explicitly state when not to use this tool, but the context strongly implies it is for writing content to a file.

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?

Discloses the method ('CDP Input.insertText') and mentions clearing the field, but does not elaborate on side effects (e.g., event triggering, hidden inputs). Annotations are absent, so the description carries full burden 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?

Single sentence of 14 words, front-loaded with key action. Efficient but could benefit from a brief usage note without becoming verbose.

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?

No output schema, so description should hint at return value or success/failure. Lacks details on error handling, focus requirements, or what happens after fill. Adequate for a simple tool but not fully complete.

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

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

Schema covers both parameters with descriptions. Description adds no extra meaning beyond schema – it reiterates the action but does not clarify formatting, escape rules, or behavior for special characters.

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 action: 'Clear and fill an input field with text'. It specifies the resource ('input field') and the verb ('fill'), and distinguishes from sibling tools like browser_click or browser_text.

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 versus alternatives like browser_eval or browser_click for filling forms. No mention of prerequisites (e.g., page must be loaded, input must be visible) or when not to use.

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 the full burden. It discloses the specific properties modified (navigator.webdriver, plugins, languages, chrome.runtime, user-agent), which is solid behavioral insight. It does not mention persistence or reversibility, so it isn't fully comprehensive.

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

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

Two concise sentences with no redundancy; the first gives the purpose and the second elaborates on the mechanism. Highly 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?

For a zero-parameter tool with no output schema, the description covers the action, rationale, and specific behaviors. Minor gaps include not noting session persistence or interaction with other tools, but for the simplicity, it's nearly complete.

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

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

The input schema is empty (0 parameters), so there's nothing to explain. The description appropriately focuses on behavior. With no parameters, the baseline is 4.

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 the specific verb 'Apply' and names the resource 'browser fingerprint,' clearly distinguishing it from navigation and DOM manipulation tools like browser_goto and browser_click. It also enumerates the exact properties normalized, leaving no ambiguity about the tool's scope.

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

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

It explicitly states the intended context: 'in CI/testing' and the goal 'to reduce false-positive automation detection.' While it doesn't list alternatives or exclusions, the stated use case is enough for an agent to decide when to invoke it.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It usefully explains the static-first fetch strategy, automatic escalation to CDP for JavaScript-heavy pages, and that the result includes title and URL. It does not mention side effects such as replacing the current page state or wait-for-load 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?

Two short sentences front-load the core purpose and return values, then add a compact, relevant note about static-first behavior. Every sentence earns its place with no filler or repetition.

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

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

For a one-parameter navigation tool, the description covers the essential inputs, outputs, and the static-vs-JS handling strategy. The main gap is the reference to a 'mode field' without explaining its possible values, especially since no output schema is provided to fill that in.

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 single parameter is already fully described in the schema ('URL to navigate to'), and the description only repeats the notion of a URL. Since schema coverage is 100%, the baseline of 3 applies; the description adds no extra guidance about URL formats or edge cases.

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 a specific action ('Navigate to a URL') and identifies key return values ('Returns page title and URL'). It is easy to tell this is the core navigation tool, but it does not explicitly differentiate itself from sibling navigation-related tools such as browser_newTab or browser_back.

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 intended use is implied: an agent should call this when it needs to navigate to a URL. However, the description gives no explicit guidance on when to prefer browser_goto over alternatives like browser_newTab, nor does it mention 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?

No annotations provided, so the description carries full responsibility. It fails to disclose behavioral traits such as whether it modifies state, requires permissions, or handles errors. It simply states the function without additional 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 a single sentence without fluff. It is front-loaded with the action. However, it could be slightly more informative without losing conciseness.

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

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

For a simple tool with one parameter and no output schema, the description is adequate but incomplete. It doesn't clarify behavior when selector is omitted (full page) or when selector matches multiple elements.

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% (single parameter 'selector' described as 'Optional CSS selector'). The description adds no new meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'HTML source', with an optional CSS selector. It distinguishes from sibling tools like browser_text (which gets text) and browser_screenshot (which gets images).

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 vs alternatives. While the description implies it's for HTML, it doesn't mention scenarios or exclusions (e.g., use browser_text for visible text). The sibling list provides context but no direct 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 are provided, so the description carries the full burden. It accurately describes the read-only listing behavior and output fields, but does not disclose additional traits such as return format or potential side effects, though none are expected for a list 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, well-structured sentence that conveys all essential information without any unnecessary 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?

With no parameters and no output schema, the description adequately explains what the tool does and partially describes the return values. It does not specify the structure or format of the returned list, but given the simplicity, it is nearly complete.

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

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

The tool has zero parameters, so the baseline is 4. The description adds value by indicating the output content (cookie counts and save dates), which provides meaning beyond the empty 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 lists all saved browser sessions and specifies the included data (cookie counts, save dates). It uses a specific verb and resource, distinguishing it from sibling tools like browser_listTabs.

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

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

Usage is implied by the listing nature of the tool, but the description does not explicitly state when to use it or contrast it with alternatives. No exclusions are mentioned, so 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?

No annotations are present, so the description must convey safety and behavior. The verb 'List' strongly implies a read-only operation, and the description discloses the exact output fields, providing reasonable transparency for a simple query tool. It lacks explicit statements about side effects or browser requirements, but none are strongly expected for a list 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?

A single sentence with no filler; the tool's action and output contents are specified immediately. Every phrase adds value.

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

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

For a simple list operation with no output schema, the description adequately covers return content (IDs, titles, URLs, active status). Minor omissions like empty-tab-list behavior or error conditions prevent a perfect score.

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

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

The tool has zero parameters, so the input schema carries no burden. The description correctly implies that no arguments are needed, meeting the baseline for a parameterless tool.

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 ('List') with a clear resource ('all open browser tabs') and enumerates the returned fields (IDs, titles, URLs, active status). This clearly distinguishes it from sibling tools like browser_newTab or browser_closeTab, which modify tabs, and from browser_status, which likely reports a single tab or browser state.

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

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

No guidance is given about when to use this tool over alternatives such as browser_status or browser_listSessions. The description only states what it does, leaving the agent to infer the appropriate context from the tool name and sibling set.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that navigation is required for cookies to take effect, which is valuable, but it does not explain whether loading overwrites or merges existing cookies or what happens if the session name doesn't exist. This is some but not rich 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 two sentences with no redundant wording. The first sentence states the purpose, and the second adds a critical usage note, making it efficient and well-structured.

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

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

Given the tool's simplicity (one parameter, no output schema), the description adequately covers the essential information for correct invocation: what it does and the required post-step. It lacks explicit error behavior or cookie-overwrite semantics, but these are not critical for a single-parameter load tool.

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

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

The input schema has 100% coverage with a clear description for the 'name' parameter, so the baseline is 3. The tool description adds no additional semantic detail about the parameter beyond what the schema already provides.

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

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

The description clearly states the action ('Load') and the resource ('saved browser session (cookies) from disk'), making it distinct from sibling tools like browser_saveCookies and browser_listSessions. It also includes the important follow-up requirement to navigate to the target domain, which fully clarifies its scope.

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 on how to use the tool by instructing the user to navigate after loading, but it does not explicitly mention when not to use it or name alternatives. This is a minor gap, so it earns a 4 rather than 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?

With no annotations provided, the description carries the burden of disclosure. It reveals the important behavioral detail that the new tab is automatically switched to, which is not inferable from the schema. It does not, however, mention any potential side effects (e.g., if the URL is invalid or if a blank tab is opened). For a low-complexity tool, this is good but not exhaustive, hence a 4.

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 sentences long, front-loaded with the core action, and every word adds value. It states the primary function, the optional behavior, and the automatic switching without any 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?

For its simplicity (1 optional parameter, no output schema, no annotations), the description provides complete information: what the tool does, the optional navigation, and the automatic switching. There are no hidden complexities requiring further explanation, making this a fully complete description.

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%, with the 'url' parameter described as 'URL to navigate to in the new tab (optional)'. The tool description adds no further meaning beyond restating this in prose ('optionally navigate to a URL'). Since the schema already fully documents the parameter, a baseline score of 3 is appropriate.

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

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

The description clearly identifies the action: 'Create a new browser tab' with an optional navigation step, and distinguishes itself from siblings like browser_goto (which navigates the current tab) and browser_switchTab (which switches to an existing tab) by explicitly mentioning the automatic switch. This is a specific verb+resource+scope statement.

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

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

The description implies when to use the tool: when a new tab is needed, optionally with a URL, and notes that it automatically becomes the active tab. It does not explicitly name alternatives or state exclusions, but the context is clear for a simple browser operation. A score of 4 is appropriate for clear context without explicit 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 provided, the description carries the full burden of behavioral disclosure. It states the restart is 'clean' and useful for 'clearing state', which hints at side effects like losing session data. However, it does not explicitly warn that all tabs and sessions will be closed or that cookies/saved state may be lost, which are important for a restart operation. It is not misleading but is not fully transparent about the full extent of state reset.

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 that lead with the action and immediately follow with concrete use cases. Every word adds value — there is no fluff or repetition. It is well-structured and front-loaded.

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

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

For a parameterless tool, the description covers the core purpose and usage scenarios. However, given the surrounding context (browser session management, cookies, multiple tabs), it omits important caveats like the loss of open tabs and saved sessions. This is a gap that could lead an agent to invoke it without understanding how disruptive a restart is. The description is adequate but not fully complete.

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

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

The tool has zero parameters, so per the rubric the baseline is 4. The description does not need to add parameter semantics, and it does not attempt to. This score reflects the simplicity of the parameterless input 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's purpose: to cleanly restart the browser process. It specifies the resource (browser process) and the action (restart), and distinguishes from siblings like browser_closeTab or browser_newTab by targeting the entire process rather than individual tabs. The additional context about freeing memory and recovering from issues reinforces the specific use case.

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

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

The description gives clear context for when to use the tool: freeing memory, clearing state, or recovering from issues during long-running sessions. It does not explicitly mention when not to use it or alternative tools, but the provided scenarios are specific and actionable, placing it just below the highest bar.

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

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

The description discloses that sessions persist across agent and server restarts, a key non-obvious behavioral trait. It also implies persistence via the phrase 'works for days,' but it doesn't address overwrite behavior or failure modes.

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

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

The description is only two sentences and front-loads the purpose. The quoted tagline and persistence statement are meaningful and concise, with no wasted words.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the core action and persistence, which is sufficient. It could mention behavior for duplicate names, but that's a minor gap.

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

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

The input schema already fully describes the 'name' parameter with examples, so the description adds no extra parameter semantics. Per the baseline rule for high schema coverage, this scores 3.

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 ('Save') and resource ('current browser session (cookies)'), clearly distinguishing it from sibling tools like browser_loadCookies or browser_listSessions.

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 tagline 'Login once, agent works for days' implies the primary use case is saving an authenticated session after login, giving clear contextual guidance. It does not explicitly mention alternatives or when not to use, but the context is strong enough.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only restates the selector behavior already present in the schema, and omits critical details such as the output format (e.g., base64 vs. file path) or whether the operation is non-mutating, leaving the agent uncertain about return values and 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, efficient sentence that front-loads the core action. It is compact and every word contributes to understanding, with 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 no output schema, so the description should explain what the screenshot returns, but it does not. However, the tool is simple with all optional parameters, and the purpose is clear. The missing return format and lack of explicit confirmation that it is a read-only operation create a moderate gap.

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

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

Schema description coverage is 100%, so all three parameters already have descriptive text. The description adds no new semantic information, merely echoing the selector parameter's purpose. The baseline of 3 is appropriate because the schema handles 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 uses a specific verb ('Take a screenshot') and identifies the resource ('current page'), with an optional CSS selector for element capture. This clearly distinguishes the tool from sibling browser tools like browser_html or browser_click.

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 explicit guidance on when to use this tool versus alternatives. It does not mention situations where a screenshot is preferred over textual tools, nor does it state any prerequisites or exclusions.

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

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

With no annotations, the description must disclose behavioral traits. It only states the action and a use case, but does not explain whether the change applies to the current tab, whether it causes a reload, or how it affects subsequent operations. This is minimal information.

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

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

Two short sentences, no filler. The first sentence states the action, the second gives the use case. Very efficient.

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

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

For a simple setter with two parameters and no output schema, the description is adequate but could mention the scope (current tab) and that the change applies to subsequent browser interactions. Given the minimal complexity, a score of 3 is appropriate.

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 already provides complete descriptions for both parameters (width and height with units and defaults). The description 'width × height' adds no new meaning, so it meets the baseline of 3.

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 'Change' and identifies the resource 'viewport size' with dimensions. It clearly distinguishes from sibling tools like browser_goto or browser_screenshot by focusing on viewport configuration.

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 responsive testing' provides a clear context for when to use the tool, though it does not explicitly exclude alternatives. There is no competing viewport tool among siblings, so this guidance is sufficient.

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 communicates that this is a read-only status snapshot and adds non-obvious detail about live MCP/Chromium memory readings and budgets. It does not describe the exact response format or failure behavior, but it is reasonably transparent for a status getter.

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 compact sentences with no filler. It front-loads the core purpose, then adds a version note that provides genuinely useful behavioral context about resource readings.

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

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

For a parameterless status tool with no annotations and no output schema, the description covers the key bases: purpose, included data, and practical rationale. It does not define the return shape, but that is a minor gap for this simple getter.

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 coverage is 100%, so there is no parameter semantics burden on the description. Per the baseline for zero-parameter tools, this dimension is well satisfied.

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

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

The description names a specific operation, 'Get browser and page status', and enumerates its contents: opened tabs, connection info, and live resource readings. This clearly distinguishes it from navigation and interaction siblings, though it does not explicitly differentiate it from browser_diagnose or browser_listTabs, which could partially overlap.

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 'so the agent sees pressure before Android does' implies the tool is useful for proactive resource monitoring, but there is no explicit when-to-use or when-not-to-use guidance. It does not name alternatives such as browser_diagnose or browser_listTabs or explain when one should be preferred.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action and parameter, with no mention of side effects, error handling, or return value, leaving the agent without insight into what happens after switching.

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 words. It is concise and to the point, earning its place without unnecessary elaboration.

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 with one parameter and no output schema, so the description and schema provide a basic understanding. However, it lacks guidance on how to obtain targetId (e.g., via browser_listTabs) and what happens after switching, making it minimally sufficient but not fully complete.

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

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

The input schema fully describes targetId as 'Target tab ID to switch to' (100% coverage). The description adds no new semantic detail beyond restating that switching is done 'by targetId', so the baseline of 3 applies.

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

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

The description clearly states the verb 'Switch' and the resource 'browser tab' with the mechanism 'by targetId'. It is distinct from sibling tools like browser_newTab, browser_closeTab, and browser_goto.

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 usage context is clear: you need a targetId (likely from browser_listTabs) to switch to an existing tab. It does not explicitly mention alternatives or prerequisites, but the purpose is unambiguous and distinct from other tab-related 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?

No annotations are provided, so the description must fully convey behavioral traits. It mentions 'visible text content' but does not clarify what 'visible' entails (e.g., hidden elements, scripts), nor does it specify if the tool waits for page load or returns whitespace-trimmed text.

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 efficiently communicates the tool's function with no unnecessary words. It is front-loaded and 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 the lack of an output schema and the presence of many sibling tools (e.g., browser_eval), the description is too brief. It does not specify the format of the returned text (e.g., plain string, lines), what happens when no selector is provided, or any side effects.

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% for the only parameter 'selector', which is described as 'Optional CSS selector'. The tool description adds that it retrieves text content from that selector, providing minimal additional context beyond the schema.

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

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

The description clearly states the tool retrieves visible text content from a page or a specific CSS selector. It distinguishes from sibling tools like browser_html (HTML content) and browser_title (page title).

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 usage guidelines are provided. The description does not specify when to use this tool versus alternatives like browser_elements or browser_eval, nor does it mention prerequisites or limitations.

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?

Without annotations, the description carries the full burden. It discloses polling interval (200ms) and timeout behavior, but does not mention what happens on timeout (error? return null?) or whether the tool returns the element. The return value is unspecified.

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 immediately conveys the purpose. It is efficient and front-loaded, though it could include additional details without becoming verbose.

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 core waiting behavior and polling, but lacks details on return value, error handling, or performance implications. For a tool with no output schema, more context on outputs would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description does not add extra meaning beyond confirming the overall behavior. Baseline of 3 is appropriate.

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

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

The description clearly states the tool waits for a CSS selector to appear or disappear, with polling details. It distinguishes from sibling tools like browser_click or browser_fill by focusing on waiting rather than action.

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 waiting on DOM conditions but does not explicitly state when to use this tool over alternatives or provide usage boundaries. It lacks guidance on prerequisites or when not to use.

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 behavioral disclosure burden. It transparently explains the recording-polling model, indicating that events are captured asynchronously and retrieved via polling. It also lists the event types. It does not mention resource limits or automatic cleanup, but the schema's 'stop' action covers cleanup, and the overall behavior is well conveyed.

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, using two sentences to convey the core behavior and workflow. The 'GROUNDBREAKING:' prefix is unnecessary hype and slightly detracts, but overall the description is well-structured and appropriately sized.

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 (two parameters, no nested objects) and no output schema, the description provides sufficient context: what events are captured, the start-poll-stop workflow, and the fact that events are collected over time. It could be more specific about the return format, but this is not critical for basic usage.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'action' and 'events' parameters. The description enumerates event types but adds no additional semantic value beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Live capture of page events (console, network, navigation, exceptions).' It uses a specific verb 'capture' with a resource, and the focus on page events distinguishes it from sibling navigation and interaction tools.

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

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

The description provides a clear usage pattern: 'Start recording, browse around, then poll to see everything that happened.' This implies when to use the tool, though it does not explicitly discuss alternatives or when not to use it. The workflow guidance is strong enough to guide an agent.

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