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

With no annotations, the description carries the full burden. It discloses the tool's read-like behavior (checking, no side effects implied) and details the return value sections (mcp, deps, browser, overall_ok, recommendations). It also notes version changes (session checks removed). However, it does not explicitly state that it is non-destructive.

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: two sentences plus a structured list of return sections. It front-loads the purpose and includes relevant version history. Every sentence contributes value without redundancy.

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

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

Given zero parameters, no output schema, and no annotations, the description provides sufficient context: what is checked, the return structure, and a version note. It is complete for the agent to understand and invoke the tool correctly.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty). Per guidelines, the baseline is 4. The description adds value by explaining the output structure but cannot add parameter semantics since there are none.

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 verb ('check') and resource ('MCP environment, dependencies, and browser state'). It lists specific components checked (MCP version, dependencies like esprima and playwright, browser state) and distinguishes it from sibling tools like 'compare_env' by focusing on a self-check rather than comparison.

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 initial diagnostics but provides no explicit guidance on when to use it versus alternatives like 'reset_browser_state' or 'compare_env'. The context is implicit, lacking when-to-use or when-not-to-use instructions.

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, and the description does not disclose any behavioral traits (e.g., whether it waits for element visibility, throws errors, or triggers navigation). The agent lacks safety 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?

The description is short but under-specified. It does not earn its place as it provides no additional value beyond the tool name.

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

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

Given no output schema and 0% schema coverage, the description should cover return values, errors, or prerequisites. It does none of these, leaving the agent underinformed.

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 'selector' is not explained in the description. With 0% schema coverage, the description should clarify that it expects a CSS selector or XPath, but it does not.

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

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

The description clearly states the verb and resource ('Click on a page element'), but it adds no additional context or scope beyond the tool name. It is not a tautology, but it is minimally informative.

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 'type_text' or 'navigate'. No prerequisites or context 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 provided, the description must carry the behavioral burden. It does disclose the side effect of serializing a trace transition before closing, which is useful. However, it does not mention irreversibility, session teardown, or what happens to unsaved trace data, leaving some behavior implicit.

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 filler. 'Close the brwoser' is front-loaded, and the qualifying serialization behavior is placed at the end, making the core purpose immediately clear.

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 close action with no output schema, the description covers the action and the key ordering constraint. It is complete enough to call correctly; minor details like return value or failure behavior are absent but not critical for this simple operation.

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 effectively 100%, so there are no parameter semantics for the description to add. Per the rubric, zero parameters earn a baseline of 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 a specific verb ('Close') with a clear resource ('the browser') and adds a sequencing detail ('after serializing any native trace transition'), so an agent knows exactly what action occurs. It does not explicitly compare against sibling tools, but no sibling shares the close-browser action, so it is distinguishable.

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 'after serializing any native trace transition' gives a clear procedural condition for when it is safe to call this tool. It does not name exclusions or alternatives, but the action itself (closing the browser) is distinct enough that no alternative routing is needed.

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 explains the tool collects fingerprint data and returns categorized environment data, and mentions the optional 'properties' parameter with defaults. It does not contradict any annotations (none present). It adds context beyond the 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 very concise with two short paragraphs. The first sentence immediately states the purpose. Every sentence provides value, and there is no superfluous content.

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 only one optional parameter and no output schema, the description is complete. It explains the argument, default behavior, and return type (dict). Sibling tools are diverse and this description is sufficient for an AI agent to understand when and how to use it.

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

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

The input schema has one optional parameter 'properties' with only type info. The description adds significant meaning: it explains the parameter is optional, lists default property categories (navigator, screen, canvas, WebGL, audio, timing). This compensates for the 0% schema description coverage.

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

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

The description clearly states the tool collects browser environment fingerprint data for comparison with Node.js/jsdom. It uses a specific verb ('Collect') and resource ('browser environment fingerprint data'), and distinguishes itself from siblings like 'check_environment' which might check individual properties.

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 explicitly mentions the use case: comparison with Node.js/jsdom. It implies when to use the tool but does not provide explicit alternatives or when-not-to-use scenarios. Sibling tools like 'check_environment' could be related, but no exclusionary guidance is 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?

With no annotations present, the description carries the burden of disclosing side effects and constraints. It explicitly says no requests are issued and no browser is launched, and it warns that results may contain credentials. It does not explicitly state 'read-only' or describe failure modes, but the non-mutating nature is strongly implied by 'compare captured requests.'

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 compact and front-loaded with the core purpose. The Args/Returns structure is readable, though some phrasing is cryptic and dense, such as 'Query duplicates, value order and raw URL encoding are preserved' and 'A varying field is evidence, not proof that it participates in signing.' Still, it avoids unnecessary verbosity.

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

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

There is no output schema, so the description must explain the return semantics, and it does partially. It mentions changed fields, constant names, completeness limits, and preserved aspects like query duplicates and URL encoding. However, it lacks a concrete shape or example of the returned structure, and the behavior around partial vs. complete comparisons remains somewhat ambiguous.

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 provides titles and defaults but no descriptions, so the description fully compensates. Every parameter is explained with meaningful details: request_ids are tied to list_network_requests, include flags control comparison scope, and max_value_chars/max_fields clarify truncation and limits. It also adds important nuance about full-value digests and exact byte checks.

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 ('compare'), the resource ('captured requests'), and the valid count range (2..10). It also distinguishes this from live network actions by noting it does not issue requests or launch a browser, which separates it from siblings like intercept_request or launch_browser.

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

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

It gives clear context that this is for comparing previously captured requests and that no live browser/network activity is involved, which implies when it should be used. It does not explicitly name alternatives or list when-not-to-use cases, but the workflow hint of using request_ids from list_network_requests provides enough guidance.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly. It discloses the destructive outcome of an unfiltered delete ('no filter = clear all'), the boundary-match/subdomain behavior of domain filtering, the requirement of cookies_list for set, and the return format for each action. This is far beyond minimal transparency.

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

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

The description is well-structured with clear sections for the replacement note, args, and returns. Every sentence provides useful information—no filler. Despite moderate length, the formatting makes it easy to scan and the critical safety warning is included without bloat.

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 all four parameters, all three actions, filter interactions, the destructive edge case, and return values. Even with an output schema present, it includes enough behavioral context for an agent to safely and correctly invoke the tool. Nothing essential is missing for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must explain every parameter, and it does. It defines the action values with behaviors, explains domain as a host/parent-domain filter with subdomain matching, specifies cookies_list as cookie dicts for set, and clarifies name as a delete filter. This fully compensates for the bare 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 manages cookies with three distinct actions (get, set, delete), and explicitly notes it replaces get_cookies / set_cookies / delete_cookies. This makes the tool's scope immediately clear and distinguishes it from the legacy alternatives and unrelated siblings.

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

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

It provides explicit action-level usage guidance, including when to use each action, filter semantics for get/delete, and the requirement of cookies_list for set. The note that it replaces three legacy tools directly tells the agent to prefer this tool over them, and the warning about no filters clearing all cookies gives a specific when-not-to behavior.

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

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

No annotations are provided, so the description carries the full burden. It discloses return format keys, differences between auto and json_ascii modes, execution world behavior (isolated vs main with fallback), failure behavior ('Evaluation is never replayed after a failure'), and specific handling of undefined/null/void/Symbol. This is exceptionally transparent.

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

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

The description is front-loaded with the core purpose and version note, then organized into Args and Returns sections. It is longer than necessary—the v1.0.1 changelog line and some verbosity could be trimmed—but it is well-structured and every section earns its place given the tool's complexity. The length is justified by the need to explain subtle behaviors.

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 7 parameters, no output schema, and no annotations, this description is remarkably complete. It documents all return keys, error hint behavior, execution backends, and frame selection. The agent receives everything needed to call the tool correctly without additional external knowledge. It also preemptively addresses common pitfalls (e.g., lone surrogates, non-finite numbers).

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

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

Schema description coverage is 0%, so the description must compensate entirely. It explains every parameter: expression (including the IIFE caveat), await_promise (default True), world (with isolated vs main details and fallback), frame_url/name/index (with wildcard support), and result_format (auto vs json_ascii). Each parameter's purpose and nuances are covered, exceeding what a bare schema would provide.

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 'Execute an arbitrary JavaScript expression in the page context and return the result.' It names the resource (page context) and the specific action. No sibling tool performs the same function (e.g., hook_function injects hooks, not evaluate expressions), so differentiation is inherent.

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 guidance on how to use the tool (e.g., single-expression requirement, IIFE wrapping, world selection, frame targeting) but does not explicitly contrast with alternative tools or state when not to use it. Since it is a general-purpose evaluation tool, the context is clear enough for an agent to infer its appropriate 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 full burden and does so thoroughly. It discloses that existing files are never overwritten, default masking behavior, retention of URL paths, absence of full anonymization, and the warning to keep original captures out of public repositories. It also describes the return payload including redaction mode and pending/dropped work.

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 structured with Args and Returns sections, and every sentence adds operational value. It front-loads the core purpose and packs important caveats without redundancy.

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

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

Despite having no output schema and no annotations, the description gives sufficient context for an agent to invoke the tool correctly and interpret the result. It covers all four parameters, return values, and important behavioral constraints. The only minor omission is mention of prerequisites like an active capture, but the reference to network_capture covers the lifecycle adequately.

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

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

Schema description coverage is 0%, so the description must explain parameters, and it does. Each parameter is given meaningful semantics: save_path is a new local JSON path that never overwrites, include_body is gated by include_sensitive, include_sensitive details the redaction trade-off, and url_filter is an optional substring filter.

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

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

The description states a specific verb ('Export') and resource ('versioned JSON snapshot of this manager's retained capture'), clearly distinguishing it from siblings like network_capture and export_state. The scope is immediately understandable.

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 this tool and explicitly directs users to network_capture(stop, wait_timeout_ms) for a settled snapshot. It also clarifies that include_body does not fetch or replay requests, preventing misuse. It does not explicitly name export_state as an alternative, but the export-specific context is strong.

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 but only mentions it exports state and returns a dict. It does not disclose whether it is a read-only operation, permissions needed, file overwrite behavior, or side effects, leaving gaps in transparency.

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

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

The description is concise and includes both purpose and parameter explanation, but could be better structured with a separate returns section and less informal formatting.

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 the tool and siblings like import_state, the description is mostly complete. It mentions what is exported and what it returns, but lacks details on behavior like overwriting files or error 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?

The description adds meaningful context to the single parameter save_path by indicating it is a local file path for saving state JSON, compensating for the 0% schema description coverage.

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

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

The description clearly states the verb 'Export', the resource 'complete browser state', and specifies it includes cookies and storage. It differentiates well from sibling tools like import_state (import) and reset_browser_state (reset).

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 saving browser state but does not explicitly state when to use it versus alternatives like import_state or reset_browser_state, nor does it provide context for when it is appropriate.

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

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

With no annotations, the description covers key behaviors: it returns a list of filtered logs and clears the buffer if the clear parameter is True. It could mention that it only reads existing logs without affecting the page, but it's adequate.

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?

Extremely concise: three sentences for purpose, then list of parameters and return type. No unnecessary words, front-loaded with the action.

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

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

Covers purpose, parameters, behavioral effect of clear, and return structure. With an output schema present, the return description is sufficient. The tool is straightforward and well-documented.

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?

Despite schema description coverage being 0%, the description fully documents all three parameters (level, keyword, clear) to clarify their meaning and effect, compensating completely.

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 gets console output from the page, with a specific verb and resource, and distinguishes from sibling tools like get_storage or take_snapshot.

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

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

No guidance on when to use this tool vs alternatives. The description only explains what the tool does, not context for choosing it over other tools.

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

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

With no annotations, the description carries full burden. It states the tool is read-only (captured request details) and describes parameters, but does not specify behavior on invalid request_id, rate limits, or performance implications. Decent coverage but lacks edge-case details.

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

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

Description is concise (3 sentences and a param list) and front-loaded with the purpose. Each part adds value, though the returns section could be more detailed. 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 no output schema, the description mentions return as 'dict with request and response details' but lacks specifics on structure. For 4 params, it covers param semantics well but omits error handling and response format details.

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

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

Schema coverage is 0% (no descriptions in schema), so description must compensate. It explains request_id source, default values for booleans, and the special value -1 for max_body_size. This adds significant meaning beyond schema titles and types.

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 'get full details of a specific captured network request', specifying verb and resource. It distinguishes from sibling 'list_network_requests' (which lists requests) and 'get_request_initiator' (which gets the initiator).

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 by referencing 'from list_network_requests' but does not explicitly state when to use this tool over alternatives, nor does it provide when-not-to-use guidance. No exclusions or prerequisites 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?

Without annotations, the description must carry behavioral transparency. The verb 'Get' implies a read-only operation with no side effects, but it does not explicitly state that no state changes occur or that it is safe to call at any time. The description provides a basic indication but lacks explicit assurances.

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 efficiently communicates the core function without superfluous details. It is front-loaded with the action and resource, making it immediately clear to the reader.

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 that the tool has no parameters and no output schema, the description is sufficient for an agent to understand what the tool does and when to call it. The phrase 'for targeted tools' hints at a specific use case but does not leave critical gaps in understanding for a simple getter operation.

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 no parameters, and the schema coverage for parameters is 100% (none exist). Per the rubric, the baseline score is 3 when there are no parameters to describe, and the description does not add any parameter-related information since there is nothing to explain.

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 ('Get') and the resources ('page metadata plus a zero-based frame list'), which distinguishes it from sibling tools like 'take_screenshot' or 'reload'. The phrase 'for targeted tools' is slightly vague but does not obscure the primary 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 does not specify when to use this tool versus alternatives, nor does it mention any prerequisites or contextual conditions. It only states what the tool does, leaving the agent to infer when it is appropriate without 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 exist, so the description carries full responsibility. It openly discloses limitations (matching may be incorrect, Firefox fetch returns null, interceptor interference) and provides workarounds. This is highly transparent.

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

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

Description is longer than average due to limitations and workarounds, but it is well-structured with paragraphs and bullet points. Every sentence adds value, so it remains 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?

Covered prerequisites, return dict fields, and limitations. Missing some context like how to retrieve request_id, but this is likely covered by sibling tools (e.g., list_network_requests). Overall sufficient for an agent.

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

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

Schema has no description, but the tool description includes an Args section explaining request_id as 'The ID of the request.' This is minimal but adequate; could benefit from mentioning how to obtain the ID (e.g., from list_network_requests).

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

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

States a specific action (get the JS call stack) and a specific resource (network request). Clearly distinguishes from siblings like get_network_request, which likely returns request details rather than the initiator stack.

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

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

Provides prerequisites (inject_hook_preset before navigating) and contextual guidance (investigation lead, corroborate with captured inputs). Does not explicitly name alternative tools, but the context is sufficient for typical 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?

Without annotations, the description carries full burden. It conveys a read operation ('Get') and specifies the return format as a dict of key-value pairs, but omits details like error handling, permissions, or idempotency.

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?

Extremely concise: three sentences with no waste. The purpose is front-loaded, and the parameter and return are clearly separated.

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 getter with 0 required parameters and no output schema, the description covers the core behavior and return format. Minor gaps (e.g., error states) but acceptable given low complexity.

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

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

Schema coverage is 0%, but the description explains the single parameter 'storage_type' with its allowed values ('local' for localStorage, 'session' for sessionStorage), adding significant meaning beyond the schema's bare type declaration.

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 'contents of localStorage or sessionStorage', distinguishing it from sibling tools that handle other aspects like page info or console logs.

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., get_page_info for DOM data). The context of siblings is not leveraged to set 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 exist, so the description carries the full burden. It describes internal merging behavior but does not disclose whether the tool has side effects (e.g., modifying the cache) or if it is read-only. This lack of transparency lowers the score.

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

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

The description is moderately concise but contains dense technical details that could be clearer. It is not excessively long, but some sentences are convoluted and could be better structured with bullet points or simpler phrasing.

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 absence of an output schema and annotations, the description should explain return values, error conditions, and parameter meanings. It does none of that, focusing on internal caching behavior, so it is incomplete for an agent to use effectively.

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

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

The schema has 7 parameters with no descriptions and no coverage in the description. The description mentions frame metadata but never explains parameters like clear, world, frame_url, or function_path. Thus the description adds no semantic value to the inputs.

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

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

States a clear action (retrieve) and a specific resource (in-page traces and cross-navigation cache). It also distinguishes itself by describing merge semantics, but does not explicitly name a sibling tool, so a 4 is appropriate rather than a 5.

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

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

Does not provide explicit guidance on when to use this tool versus alternatives like list_trace_files or query_trace_file. Some implicit hints about the authoritative cache exist, but no clear selection criteria 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?

With no annotations, the description carries the full burden and delivers exceptionally. It discloses side effects (json serialization executes getters/toJSON and may coerce via String; preview reads no properties), async semantics (a returned Promise is never awaited or settled-observed; completion is always 'sync'), failure isolation (logging failures don't replace original results), non-reset of counters (clearing logs doesn't reset max_captures or callIndex), intrinsic snapshotting at first install, and limitations (2000-char truncation, third-party modified intrinsics unrecoverable, constructor/new semantics out of contract). The watch_assignments temporary setter installation is explicitly called out.

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?

Densely informative with a clean structure: purpose line, bulleted parameter list, a 'Trace semantics' section, then Returns. Nearly every sentence carries semantic weight. Minor redundancy exists (position='after' and serialization caveats appear in both the parameter list and the trace-semantics section), and the 'Replaces hook_function + trace_function' line is stale filler. Justified length given 18 parameters and the late-binding/serialization complexity, but a few duplicated details could be trimmed.

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?

Parameter and behavioral coverage is superb, but the output contract is thin: with no output schema, the description offers only 'Returns: dict with status, target, mode' — status values, what 'target' contains, and error/timeout outcomes (e.g., when the late-bound target never appears within wait_timeout_ms) are unspecified. For a tool this complex, an agent cannot fully predict success or failure shapes from the description alone.

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

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

Schema description coverage is 0%, and the description compensates completely: all 18 schema properties are addressed with real semantics beyond names and defaults — examples for function_path, context vars (arguments, __this, __result, and its position='after' restriction) for hook_code, value sets for mode/position/world/serialization, persistence-dependent defaults for wait_timeout_ms and watch_assignments, the polling range for poll_interval_ms, and exact frame targeting semantics for frame_url/frame_name/frame_index. Nothing in the schema is left unexplained.

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

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

The opening line — 'Hook or trace a function (v0.9.0 unified)' — gives a specific verb and resource, and the mode parameter (intercept vs trace) crisply splits the two behaviors. The function_path examples ('window.encrypt', 'XMLHttpRequest.prototype.open', 'JSON.stringify') make the target concrete. Though the 'Replaces hook_function + trace_function' note references tools absent from the sibling list, the core purpose is unmistakable.

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?

In-tool guidance is strong: mode selection, the difference between intercept and trace, frame targeting, and world choice are all explained, and defaults are given by persistence flavor. However, the description never contrasts with current siblings like inject_hook_preset, trace_property_access, or hook_jsvmp_interpreter — an agent has no explicit signal for when to pick this tool over those. The 'Replaces' note targets tools that no longer exist, so that guidance is inert.

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 details behavioral traits: detectability of proxy mode, the need to install hooks before navigation, persistence, and the wrapping of Reflect.get/apply and Proxy installation on globals.

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?

Well-structured with summary, limitations, important notes, and Args section. Slightly lengthy but every sentence adds value. Could be tightened slightly, but overall effective.

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

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

Given 8 required and optional params, no output schema, and no annotations, the description provides complete coverage: explains return value, usage patterns, edge cases, and limitations. 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?

Schema coverage is 0%, but description thoroughly explains each of the 8 parameters, including default values, constraints (e.g., track params only for proxy mode), and purpose (e.g., script_url for filtering, max_entries for buffer cap).

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 installs a JSVMP runtime probe and explains multi-path instrumentation. It is distinctly different from sibling tools like hook_function or inject_hook_preset, which target other intercept mechanisms.

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

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

Provides explicit when-to-use guidance, including a step-by-step sequence for sync-loaded SDKs. It also warns against using 'proxy' mode for RS/AK-style anti-bot and directs to alternatives like instrumentation or mode='transparent'.

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 reveals that a new context is created, but lacks details on side effects (e.g., what happens to existing contexts, whether the import overrides any existing state). No annotations are provided, so the description carries the full burden.

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

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

The description is brief and covers the essential information: purpose, argument, and return value. It could be slightly more concise, but it is well-structured with clear sections.

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 the tool (one parameter, no output schema), the description provides adequate information to understand basic usage. However, it lacks details on error handling, expected behavior when the file is invalid, or interaction with the current browser 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?

The schema has one parameter with no description, but the description adds context: state_path is a path to a JSON file exported by export_state. This adds meaning beyond the schema type and title.

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: importing browser state from a JSON file by creating a new context. It distinguishes itself from sibling tools like export_state and reset_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?

The description implies usage after export_state to restore state, but does not provide explicit guidance on when to use this tool versus alternatives like reset_browser_state, nor does it mention any prerequisites or context state requirements.

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

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

With no annotations, the description carries full burden. It mentions persistence and return format, but does not disclose potential side effects, error handling, or impact on the page.

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

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

Description is concise, well-structured with a clear header, bulleted preset list, and separate sections for args and returns. 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 no output schema, description adequately explains return value. Lacks error details but is sufficient for a simple tool with 2 parameters.

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

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

Schema has 0% coverage, so description fully explains parameters: preset names and options, and persistent's behavior (survives navigation). Adds significant meaning beyond raw 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 injects a pre-built hook template for common reverse engineering tasks, listing specific presets. This distinguishes it from siblings like hook_function, which injects custom hooks.

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 through the listed presets for common tasks, but lacks explicit guidance on when to use this tool versus alternatives like hook_function or when not to use it.

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

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

The description discloses key behavioral details: route interception only catches post-registration requests, scripts run in the main world, fallback behavior on AST errors, and the meaning of frame_index. However, it omits potential side effects like performance impact or error responses, but given the absence of annotations it still carries a substantial transparency burden.

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 long but well-organized with clear sections (overview, args, returns, important timing note). It front-loads the core purpose and immediately explains the critical timing constraint. While it could be trimmed, the length is justified given the tool's complexity and 24 parameters.

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 lacks a detailed output schema specification; it only says 'Returns: dict with action-specific results.' It mentions that logs include tap events and possibly source-site maps, but does not describe the exact event structure, log response format, or error handling. For such a complex tool, this leaves gaps in understanding the expected output.

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?

Every schema parameter (24 total) is described in the Args section, including purpose, defaults, and applicability per action. This goes far beyond the bare parameter names in the schema, adding meaningful context for filter parameters, mode specifics, and the behavior of include_source_site and on_oversized.

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

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

The description clearly states the tool's purpose as JSVMP source-level instrumentation, lists the specific actions it performs, and explicitly mentions it replaces four prior tools. This makes the tool's role distinct from siblings like hook_jsvmp_interpreter and trace_property_access.

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

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

The description provides explicit timing guidance with an 'IMPORTANT' section explaining the need to call install before navigate for sync-loaded scripts, and gives a concrete pattern (launch_browser, install, navigate). It also explains when to use reload as an alternative and how filters reduce overhead, making usage conditions clear.

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 explains each action (log, block, modify, mock, stop) and associated parameters for modify and mock. However, it omits details like whether interception persists across navigation, how to remove interceptions, or any side effects on the browser state.

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

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

The description is a single paragraph that efficiently covers all parameters and their roles. It uses a list-like format with lines starting with parameter names, which aids readability. However, it could be slightly more structured (e.g., bullet points) for easier scanning.

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

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

Given no output schema and no annotations, the description lacks important context: it does not describe the return value, how to see intercepted requests, how to remove interceptions, or the lifecycle of the interception. The tool deals with mutable state, but these aspects are not addressed.

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

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

The schema has 0% description coverage, so the description must compensate. It does so effectively, explaining url_pattern with a glob example, listing all five action values, and clarifying the conditional use of modify_headers, modify_body, and mock_response. This fully covers the purpose and usage of each parameter.

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

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

The description clearly states the tool's purpose: 'Intercept network requests matching a pattern.' It uses a specific verb and resource, and the actions (log, block, modify, etc.) further clarify its function. However, it does not explicitly differentiate this tool from siblings like network_capture or list_network_requests, which also deal with network requests.

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 lists the possible actions but provides no guidance on when to use this tool versus alternative network tools such as network_capture or list_network_requests. There is no mention of prerequisites, exclusions, or context for choosing interception over other methods.

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 behavioral disclosure burden and does so thoroughly. It reveals that attach mode ignores all other launch arguments, that close_browser() in attach mode only disconnects while the server keeps running, that enable_trace requires a custom camoufox-reverse build, and that browser_version must match the active browser's exact build. These non-obvious side effects and constraints are exactly what an agent needs to avoid misusing the tool.

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

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

The description is long but systematically organized with an Args block and a Returns line, one parameter per line, and logical grouping. It front-loads the core purpose and devotes space only where needed for complex behavior. Given 13 parameters and two distinct modes, no sentence feels redundant 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 description covers launch and attach modes, parameter interdependencies, operational caveats (server persistence, font-metric parity, shared resources), and the return value shape as a dict with status, config, and page list. Even without an output schema, the agent has enough information to call the tool correctly and interpret the result at a high level. No critical details are missing.

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

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

Schema description coverage is 0%, so the description fully compensates by documenting all 13 parameters in the Args block. Each parameter gets meaningful context: defaults, allowed values ('auto', 'windows', 'macos', 'linux'), operational effects (block_webrtc prevents IP leaks), mutual exclusion (ws_endpoint ignores other args), and cross-dependencies (enable_trace requires a specific build). This goes far beyond what the bare 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 opens with a precise action: 'Launch the Camoufox anti-detection browser, or attach to a running one.' It identifies the exact resource and clearly distinguishes between the two operational modes. This cannot be confused with sibling tools like navigate or take_screenshot, which presuppose an active browser.

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 ws_endpoint documentation explicitly states when to use attach mode versus launch mode, including the instruction to start a server with `python -m camoufox server` and pass the full websocket URL. It also cautions that in attach mode all other launch args are ignored and that close_browser() will only disconnect, not shut down the server. This gives the agent clear conditional guidance for choosing the right invocation.

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 responsibility for behavioral transparency. It explains what is returned (list of request summaries) and some retuned field semantics, but it does not state side effects, read-only nature, permissions, or potential rate limits. The lack of any mention of safety or side effects leaves uncertainty.

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 well-structured with Args and Returns sections, uses concise wording, and provides necessary detail without unnecessary fluff. It is easy to parse and sufficiently compact for the complexity of the tool.

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

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

The description covers all parameters and return format, including nuanced details about size units and after_id semantics. However, it omits potential edge cases like default ordering, empty results, or interaction with pagination beyond after_id. Still, for a list tool with filters, it is largely 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?

Despite the schema having no per-parameter descriptions, the description's Args section explains every parameter: url_filter, url_contains_domain, method, resource_type, status_code, limit, and after_id. It also provides meaningful details like limit's range and after_id's cursor behavior, fully covering 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's function: 'List captured network requests with optional filters.' This is a specific verb ('List') and resource ('captured network requests'), and it differentiates from siblings like get_network_request (singular) and intercept_request (modifying).

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 such as get_network_request, export_network_capture, or compare_network_requests. It only lists parameters and return, but does not clarify the intended use cases 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 provided, so description carries full burden. Only mentions return format but no safety traits (e.g., read-only, requires permissions) or side effects. Lacks basic behavioral disclosure for a file 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?

Extremely concise: two sentences, front-loaded with purpose in first sentence. No redundant words, every part 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?

Missing explanation of the 'limit' parameter and context about file location, ordering, or performance. Without output schema, the return format info is helpful but incomplete for a list operation.

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

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

Schema description coverage is 0%, and the description does not mention the 'limit' parameter at all. Fails to explain its purpose or effect, leaving the agent to infer from the default value.

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 the verb 'list' and resource 'trace files on disk', with context 'for post-hoc analysis'. Distinguishes from sibling 'query_trace_file' by emphasizing listing all files.

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 like query_trace_file. Implied usage from 'post-hoc analysis' but no explicit recommendations 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 exist, so the description carries the full burden. It mentions optional features and return values but omits prerequisites (e.g., browser must be launched) and fails to clarify side effects like state changes, which are expected for navigation.

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 well-structured with Args and Returns sections, covering all necessary details without unnecessary verbosity. It front-loads the primary 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 5 parameters and no output schema, the description provides a thorough list of return fields and parameter explanations. However, it lacks details on error conditions and prerequisites, leaving some gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains each parameter (e.g., 'url: Target URL') beyond the schema's basic title, adding useful context for correct usage.

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

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

The description clearly states the tool navigates to a URL with optional hook injection and redirect tracing. The verb 'navigate' and resource 'URL' are specific, and the tool is easily distinguished from siblings like 'reload' or 'take_snapshot'.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'reload', 'click', or 'wait_for'. The description lacks explicit context for choosing this tool over others.

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 memory implications of capture_body, that Playwright reads full responses before truncation, that wait_timeout affects stop behavior, and that clear cancels pending work with monotonic IDs. This is strong behavioral disclosure.

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 well-structured, compact, and scannable. Each parameter is explained in a single line with relevant caveats, and the action list is clear without unnecessary prose.

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 tool behavior, parameter semantics, and side effects, which is sufficient for correct invocation. It does not specify the exact shape of the returned status snapshot, but no output schema is required and the description states what the return represents.

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

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

Schema coverage is 0%, but the description gives meaningful semantics for every parameter: url_pattern filtering, capture_body memory trade-off, max_body_size truncation behavior, and wait_timeout_ms stop behavior. This fully compensates for the sparse 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 this is a unified control for network capture, enumerates the four action values, and distinguishes it from related sibling tools like list_network_requests and export_network_capture.

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

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

The description explains when to use start, stop, clear, and status, and notes that it replaces start_network_capture/stop_network_capture. It does not explicitly contrast with interception or listing tools, but the action enumeration provides enough 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 and the description does not mention side effects, return format, error behavior, or whether the operation is read-only. As a query tool, read-only behavior is implied but never stated, and there is no output schema to clarify results.

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 and well-structured, with a clear one-line purpose followed by a bulleted argument list. Every sentence contributes useful information and there is no redundant or irrelevant content.

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 eight parameters and no output schema, but the description does not explain the result format, pagination, or behavior across different modes. Missing parameter descriptions and lack of examples make the tool difficult to invoke correctly without additional 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?

The description covers file_path, mode, filter_object, search_query, limit, and bucket_ms, but omits filter_kind and filter_site entirely. It also does not explain default values or valid enumerated values beyond the parenthetical mode list, leaving significant parameter ambiguity.

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

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

The description clearly states the tool queries a specific historical trace file for post-hoc analysis, identifying both the action and the resource. It is distinguishable from trace-listing tools, though it references trace_property_access for mode semantics without fully defining the distinction.

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 minimal guidance on when to use this tool beyond 'post-hoc analysis' and 'historical trace file.' It does not explicitly mention alternatives or state when not to use this tool, leaving the agent to infer appropriate usage.

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 burden. It discloses that init scripts are preserved, which is a key behavioral detail. However, it omits other traits like whether the page source is re-fetched, how state is handled, or if there are side effects on network requests.

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, no wasted words. Clearly communicates the core action and a special attribute. 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 simple, one-parameter tool with no output schema, the description is nearly complete. It covers the essential behavior and parameter context. Minor gap: no guidance on the return value or error conditions, but for a reload action the outcome is generally understood.

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

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

The schema has one parameter ('wait_until') with 0% description coverage. The tool description does not explain the parameter's meaning or accepted values, leaving the agent to infer from the name and default. The schema provides the type but no additional 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 the action ('Reload') and the resource ('the current page'), and adds a distinctive detail ('preserving any init scripts') that differentiates it from sibling tools like 'navigate' or 'reset_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?

The description implies when to use (when a reload is needed while keeping init scripts) but does not explicitly state when not to use or compare with alternatives. No exclusion criteria or context for choosing this over other tools.

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

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

With no annotations, the description carries full burden. It discloses that the tool modifies state in-place and returns a dict with status, restored_objects, and cleared counts. It does not mention failure conditions or prerequisites, but the information provided is sufficient for a simple tool.

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

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

The description is extremely concise: two sentences for the main action, followed by a bullet list of arguments and returns. Every word adds value with no redundancy.

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

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

Given the simple 1-parameter schema and no output schema or annotations, the description covers the tool's purpose, the parameter's effect, and the return structure completely. No additional information is needed for correct 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?

The single parameter 'keep_persistent' is described in detail: 'If True, keep persistent init_scripts registered.' This adds meaning beyond the schema's title 'Keep Persistent' and default value, explaining the effect of the parameter.

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

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

The description clearly states the verb 'remove' and the resource 'installed hooks', with the specific action of restoring original objects in-place. This distinctly differentiates it from sibling tools like 'hook_function' which installs hooks.

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 after hooks have been installed, as it says 'remove installed hooks' and 'restore original objects'. However, it does not explicitly state when to use vs alternatives or provide when-not scenarios.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'reset browser residual state,' which is vague and does not explain the destructive effects implied by the parameters (clearing cookies, storage, hooks, network capture), reversibility, or scope. The input schema hints at side effects, but the description itself does not disclose them.

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

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

The description is a single, compact sentence with no filler. It is front-loaded with the key verb and resource and earns its place, though it could be more informative without needing to be longer.

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 six boolean parameters, no annotations, and no output schema, the description is too sparse to be complete. It does not explain return values, side effects, prerequisites, or the meaning of 'residual state,' making it insufficient for an agent to fully understand when and how 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 0% and the description mentions none of the six parameters or their semantics. The tool's parameter names are somewhat self-explanatory, but the description provides no guidance on what each flag does, what the defaults imply, or how they interact. It fails to compensate for the missing schema descriptions.

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

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

The description uses a specific verb ('Reset') and names the resource ('browser residual state') with a situational context ('after serializing trace transitions'). It is not a tautology and gives a clear sense of the action, though 'residual state' is somewhat vague and does not explicitly distinguish it from sibling cleanup tools like remove_hooks or clear_network_capture.

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 'after serializing trace transitions' provides a clear trigger context for when to use the tool. However, it does not mention when not to use it or point to alternatives among the many related sibling tools, leaving usage guidance mostly implied.

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 and delivers: never overwrites existing files, rejects truncated bodies by default, never triggers a new request, and clarifies that bytes are Playwright's decoded body (not wire/compression bytes). Return format (path, byte length, SHA-256, partial flag) is also 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?

Tightly organized into summary, Args, and Returns sections. The key differentiator ('without refetch/replay') is front-loaded, and every sentence carries information with zero 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?

Despite no output schema and no annotations, the description covers behavior, all parameters, return values, and edge cases (missing/truncated body, overwrite policy, decoded vs wire bytes). Nothing essential is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description fully compensates: request_id (requires a completed body with capture_body=True), save_path (new path, no overwrite), and allow_partial (default rejects truncated bodies) are all semantically enriched beyond the bare schema types.

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

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

States a specific verb (save), a precise resource (captured response bytes), and content types (JS/WASM/JSON/binary). The qualifier 'without refetch/replay' clearly differentiates it from sibling network tools like get_network_request, export_network_capture, and list_network_requests.

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

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

Provides clear preconditions (capture_body=True required) and failure-path guidance ('increase the capture limit and collect a new sample intentionally'). However, it never explicitly names alternative sibling tools, leaving the when-to-use contrast implicit rather than stated.

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

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

With no annotations, the description explains actions and outputs, but omits potential side effects such as whether 'save' overwrites files or if there are any destructive behaviors.

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 well-structured with Args and Returns sections, but the opening line could be more concise. Overall efficient 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?

Given the tool's simplicity and presence of an output schema, the description covers all actions and parameters. However, it could mention error handling or default behavior for 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?

The description fully compensates for the 0% schema coverage by explaining each action's parameter requirements, including the 'inline:<index>' format for URL.

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

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

The description clearly states it is for script inspection with three actions: list, get, save. It explicitly replaces three older tools and distinguishes itself from sibling browser automation 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?

It provides clear context for each action and parameter requirements, but does not explicitly state when not to use this tool or mention alternatives.

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

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

With no annotations, the description fully discloses behavioral traits: case-sensitive substring matching, dual modes (line/char) based on minification detection, and return structure. It transparently explains all relevant behaviors.

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 well-structured with a clear first sentence and an Args section. It is slightly verbose due to detailed explanations, but every sentence adds value. Could be slightly more concise, but front-loading is effective.

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 no output schema, the description covers return format (dict with matches, total_matches, mode). All 5 parameters are fully explained, and the behavior is comprehensively described for a search tool. No gaps remain.

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

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

Schema coverage is 0%, so the description must carry full parameter meaning. It does so thoroughly: keyword (case-sensitive substring), script_url (None vs specific, inline support), context_chars and context_lines with defaults and mode relevance, max_results with default. No parameter is left ambiguous.

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 searches for a keyword in loaded scripts, and explicitly mentions it replaces two older tools, making its purpose unambiguous and distinct from sibling tools which are all browser automation or scripting actions.

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

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

The description explains when to use script_url=None (all scripts) versus a specific script_url (single script), and details auto-detection of minified files for mode selection. It also references the two replaced tools, providing clear context for usage without needing sibling comparison.

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, description bears full burden of behavioral disclosure. It fails to mention error behavior (e.g., invalid selector, page not loaded), output format (e.g., base64, file path), or effects on browser state. Only parameter effects are described minimally.

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?

Description is concise with purpose first, then parameter list. No unnecessary words, but could be slightly more structured (e.g., bullet points) for clarity. Still effective.

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

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

Given no output schema and no annotations, the description lacks critical context such as return value format (e.g., image data, file path), error handling, and how it differs from sibling 'take_snapshot'. Incomplete for an AI agent to reliably invoke.

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

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

Schema coverage is 0%, so description must compensate. It explains 'full_page' captures entire scrollable page and 'selector' targets a specific element, adding meaning beyond the schema's type and title. However, it does not clarify behavior when both are specified or format requirements for selector.

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 takes a screenshot of the current page or a specific element, covering basic purpose. However, it does not differentiate from sibling 'take_snapshot' which may have similar functionality, leaving ambiguity.

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

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

No guidance on when to use this tool versus alternatives like 'take_snapshot'. No mention of prerequisites, scenarios where it should not be used, or when each parameter is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does add useful context: timeout_ms failure behavior ('A hung error-page accessibility query returns an error without restarting the browser or replaying navigation') and explicit truncation limits. However, it does not state whether the tool is read-only or has side effects, though this is likely a read operation. The provided behavioral details are valuable but not exhaustive.

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 and well-structured. It front-loads the core purpose in the first sentence, then lists parameter explanations with clear formatting. No unnecessary words or redundancy. Each sentence contributes to understanding.

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 tool's purpose, parameter behavior, and error handling, which is sufficient for an agent to call it correctly. It lacks explicit read-only indication and guidance on when to use it, but these are minor gaps given the tool's simplicity and the absence of an output schema. Overall, it is fairly complete for a snapshot tool.

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

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

Schema coverage is 0%, so the description must compensate. It does so well: timeout_ms is described as 'Maximum wait for snapshot collection' with a range, and max_nodes as 'Maximum retained tree containers' with depth and string truncation details. This adds meaning beyond the schema's simple types and defaults, giving the agent clear operational 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 the tool's function: 'Get a bounded accessibility tree, or a labelled DOM fallback.' This identifies the resource and distinguishes it from sibling tools like take_screenshot (visual capture) and get_page_info (page metadata). The term 'bounded' hints at constraints, but the exact nature is not elaborated here. It is specific and actionable, though not as sharply differentiated as the calibration example.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'or a labelled DOM fallback' implies a fallback but does not explain conditions for choosing this over get_page_info, evaluate_js, or other DOM-related tools. No when-not-to-use or alternative selection criteria are 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?

The description includes a useful note that collect_values is a safe post-trace snapshot, implying no side effects for that parameter. However, it does not disclose potential effects of capture, start, stop, clear, or other actions. With no annotations, the description carries full weight but leaves room for ambiguity about state changes.

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

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

The description is compact—two sentences—and efficiently communicates the core purpose, supported actions, views, filters, and a safety note. It is well-structured and front-loaded, 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?

The description gives a reasonable overview of capabilities and a safety caveat, but it omits output format, return value details, and explicit use-case context. The sibling tool list provides some context, but the description alone is not fully self-sufficient for an agent to invoke it correctly in all scenarios.

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

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

The description adds meaning to several parameters: action's possible values, filter kinds (object, kind, site, keyword), and the collect_values flag. But it leaves duration, limit, bucket_ms, and mode indirectly defined at best. The schema has zero parameter descriptions, so the description covers some but not all parameters.

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

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

The description clearly states the tool controls or queries a Gecko native PropertyTracer run and lists supported actions and result views, making its purpose evident. It does not explicitly compare with siblings, but the verb-resource pair is specific enough.

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 alternative tracing or network tools. There are no conditions, scenarios, or examples mentioned that would help an agent decide between this and similar sibling tools.

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

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

The description mentions 'realistic keystroke delays' but fails to disclose other important behaviors like error handling, whether it clears existing text, or what happens if the selector fails. With no annotations, the description carries full responsibility and is lacking.

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 with no fluff. However, it is overly terse and could include more useful information 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?

Given the lack of annotations, output schema, and parameter descriptions, the description is insufficient. It does not cover return values, error states, or provide enough context for correct invocation of all three parameters.

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

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

The description does not explain any of the three parameters beyond hinting at the 'delay' effect. The schema has 0% description coverage, and the description adds no semantic details about 'text' format, 'selector' syntax, or 'delay' units (e.g., milliseconds).

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

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

The description clearly states the tool's action ('Type text') and resource ('input field'), with a specific behavioral detail ('realistic keystroke delays'). This distinguishes it from siblings like 'click' or 'evaluate_js', which perform different actions.

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

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

The description implies usage for typing into input fields with delays but provides no explicit guidance on when to use this tool versus alternatives, such as setting value via JavaScript. No when-not-to-use or alternative references.

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 fully carries the burden of behavioral disclosure. It reveals that code runs locally, Node vm is not a security boundary, browser timeouts do not undo/stop effects, and invalid input fails before signer code executes. This is exceptionally transparent.

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

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

The description is front-loaded with the core purpose and organized into clear Args/Returns sections. Although lengthy, every sentence earns its place by providing necessary operational or safety detail; there is no fluff 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?

Given no annotations and no output schema, the description covers all required invocation aspects: input structure, constraints, runtime options, error semantics, security caveats, and return fields. The only minor omission is a formal definition of 'signer', but the sample/expected structure makes it clear enough for correct use.

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

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

Schema description coverage is 0%, so the detailed Args section must and does compensate. Every parameter is explained with constraints, defaults, runtime behavior, and edge cases (e.g., compare_params missing keys, samples limits, timeout range). No parameter meaning is left to inference.

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

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

States a specific verb (verify), resource (signer), and completion criterion (against explicit expected values) along with a distinguishing behavior ('without sending requests'). This makes its purpose clear and differentiates it from sibling browser automation and evaluation 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 clear context for offline/local verification and detailed runtime selection guidance (browser vs node, no fallback). However, it does not explicitly name an alternative tool or state when not to use this tool, leaving some inference to the agent.

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

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

No annotations exist, so description bears full burden. It fails to disclose timeout behavior (e.g., error on timeout), blocking nature, or return values. Only states what is waited for, not how it behaves.

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, no fluff, front-loaded with purpose. Every word earns its place.

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

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

With no annotations, output schema, or schema descriptions, the description is too minimal. It lacks return value, error handling, prerequisites (e.g., browser open), and details on behavior differences between element and network wait.

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 has 0% description coverage. Description adds meaning by linking selector to element and url_pattern to network request, but does not explain timeout default/units or clarify that parameters are alternatives. Incomplete beyond parameter names.

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 an element to appear or a network request matching a URL pattern. It uses specific verb 'wait' and resources, distinguishing it from siblings like click or navigate.

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 (waiting for condition before proceeding) but lacks explicit guidance on when to use versus alternatives. No exclusions or when-not-to-use are provided.

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