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

With no annotations, the description carries the full burden and does reasonably well: it scopes which instances can be closed ('由本服务启动的浏览器实例') and distinguishes session teardown from process termination. It omits reversibility/auth/error behavior, which keeps it out of the top band.

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?

One compact sentence with the primary action (session disconnect) front-loaded and the optional closings trailing. No filler, though the branching could be marginally clearer.

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 no-annotation, no-output-schema teardown tool with three optional flags, the description covers the main behavior and the scope limitation adequately. Only precondition/irreversibility information is 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 coverage is 100%, so the baseline is 3; the description restates the three optional branches (port / closeAll / killBrowser) without adding format or precedence detail beyond the schema.

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

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

The description gives a specific verb+resource: it disconnects the current CDP session and can optionally close browser instances launched by the service. This separates it from siblings like browser_launch/browser_connect, though it does not name them explicitly.

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 implies usage through the optional branches (disconnect only, close by port, or close all), but never states when to prefer this over leaving sessions open or how it relates to browser_connect. Usage is inferable rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that a CDP session is established; it says nothing about failure modes when no browser is found, whether multiple connects are allowed, or how the session interacts with the many capture/session siblings. For a foundational connectivity tool with zero annotation coverage, this is a substantial gap.

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

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

A single sentence with no wasted words, and the primary case (debug-port browser) is front-loaded ahead of the WebSocket fallback. It is appropriately sized for the action it describes.

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 six optional parameters, no output schema, and no annotations, the description is thin for a tool that anchors the whole session workflow. It omits what a successful connection returns and how the established session is consumed by siblings. Adequate but with clear gaps.

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

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

Schema coverage is 83% (high), so the schema already documents port, targetId, autoAttach, webSocketUrl, and watchAllTargets. The description reinforces only that webSocketUrl is a full-address alternative, adding marginal meaning beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (attach/connect) and resource (a browser instance with debug port, or a WebSocket URL) and the outcome (establishing a CDP session). This is clearer than the sibling names alone, but it never distinguishes itself from browser_discover, browser_launch, or browser_close, which an agent must choose between.

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 '已开启调试端口' (debug port already open) implies a precondition — the browser must already be running — which is useful context. However, there is no explicit when-to-use guidance and no mention of the alternatives (browser_discover to find, browser_launch to start) that would tell the agent when this tool is the right choice.

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 but only states what is scanned and default ports. It omits whether the scan is non-destructive, blocking, timeout behavior, permissions required, or what is returned when no endpoints are found.

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

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

The description is a single, front-loaded sentence that states the purpose and default port range with zero waste. It is appropriately sized for a discovery 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?

For a network scanning tool with no annotations and no output schema, the description is incomplete. It does not describe the return format (e.g., list of endpoints), timeout behavior, or how results are structured, leaving an agent unable to interpret the output 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 100%, so all four parameters are already documented in the schema. The description repeats the default port range but adds no new meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description states a specific verb (扫描) and resource (本机的 DevTools HTTP 端点) and includes the default port range, making the tool's purpose clear. However, it does not explicitly differentiate itself from sibling tools like browser_connect or browser_list_processes, so it falls short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The description only states what the tool does, leaving the agent to infer that it should be used before connecting to a browser.

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 burden. It discloses the scope (Chromium-family only, executable paths) and implies a read-only listing, but says nothing about whether results are cached, how the filesystem is scanned, or what the shape of the return is.

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

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

A single front-loaded sentence with zero waste. The resource being listed comes first and the intended consumer (browser_launch) trails as a brief rationale.

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 discovery tool with no output schema and no annotations, the description is nearly complete: it names what is returned (installed browsers and their paths) and why. The only gap is the lack of differentiation from the overlapping browser_discover sibling.

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 takes zero parameters, so the baseline of 4 applies. The description adds no parameter detail because none exists, which is correct; there is no parameter gap to compensate for.

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+resource: lists locally installed Chromium-family browsers and their executable paths. This clearly distinguishes it from launch/connect siblings, though it does not explicitly set itself apart from browser_discover, which could plausibly overlap.

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

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

The trailing clause '供 browser_launch 使用' implies the downstream workflow (feed results into browser_launch), which is useful context. However, it gives no explicit when-to-use vs alternatives such as browser_discover or browser_list_processes, leaving the agent to infer the distinction.

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?

由于没有提供任何注解，描述必须承担全部行为说明责任。它明确说明了隔离 profile 不污染个人配置、开放远程调试端口、默认立即附加会话——这些都是有用的上下文。但未提及进程生命周期、清理行为、权限要求或端口冲突处理方式。

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?

单句结构紧凑，核心信息（隔离启动、调试端口、默认附加）前置，几乎没有冗余。信息密度高，但受限于句子过短，无法承载更多必要的使用指引。

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?

该工具参数多达 12 个且无注解、无输出 schema，描述仅覆盖了其中少数几个核心概念。虽然 schema 本身有 83% 的描述覆盖率可以弥补部分缺失，但对于如此复杂且具有副作用的启动操作，描述仍显得不够完整。

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 描述覆盖率为 83%，基线即为 3。描述中提到的 user-data-dir、调试端口和 attach 行为与 schema 中已有说明高度重合，未对 headless、keepProfile、watchAllTargets、targetId 等参数补充新的语义细节。

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?

明确给出了动词（启动）、资源（Chromium 浏览器）和关键属性（独立 user-data-dir、远程调试端口），足以将其与 browser_connect / browser_discover 等同类工具区分开来。但它没有像高质量定义那样点明具体的不适用场景或直接命名同类工具。

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?

描述仅隐含了使用该工具的情境（需要启动新浏览器时），没有明确说明何时应改用 browser_connect、browser_discover 或 browser_installed。默认 attach 行为提供了一点上下文，但未形成真正的使用指引。

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

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

With no annotations, the description carries the full burden and does notable work: it discloses that results are annotated as attachable/non-attachable, that attachability depends on --remote-debugging-port, and that Firefox/Safari are always non-attachable. Gaps remain (read-only nature is only implied, no mention of output shape or failure behavior).

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

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

Two tight sentences, the core purpose is front-loaded, and every clause earns its place by adding the CDP constraint and browser-exclusion behavior.

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 two-parameter read-only enumeration with no output schema, the definition covers what the agent most needs to interpret results (attachability marking). It could say more about the returned fields or whether filtering affects children, but 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?

Schema description coverage is 100%, so the schema already documents 'filter' and 'includeChildren'. The description adds no parameter-level detail, so the baseline 3 is appropriate.

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

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

States a specific verb and resource: enumerating locally running browser processes, and adds the distinguishing CDP-attachability angle. This clearly separates it from siblings like browser_installed (installed vs running) and browser_discover, though no sibling is named explicitly.

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

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

Usage is only implied – an agent can infer it should run this before browser_connect to find an attachable target, but the description never states when to use it versus browser_discover/browser_installed or any prerequisites for the call itself.

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

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

With no annotations, the description carries the full burden. It does disclose a useful behavioral fact – that results come from in-memory records as well as the captures root directory – but it never states that this is a read-only operation, nor describes return format, ordering, or whether the scan can be slow.

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?

One compact sentence, front-loaded with the action and resource. No waste, though it is arguably too terse to earn a 5 for a listing 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?

No output schema and no annotations, so the description should carry return-shape expectations. It says what gets listed but not what the agent receives back (paths? IDs? metadata?), leaving a modest but real gap for a retrieval 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 100% and there is only one optional parameter, so the schema already documents rootDir including its default. The description adds nothing beyond the schema; baseline 3 applies.

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

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

States a specific verb and resource: '列出...保存过的抓取目录', and clarifies scope as both in-memory records and results under the captures root dir. It is distinguishable from capture_save (which persists data), though it never explicitly names a sibling.

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

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

No statement of when to use this versus capture_status, resources_list, or capture_save. The agent gets a description of what is listed but no trigger condition or exclusion.

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 it does disclose concrete behavioral output: the exact set of files written to a directory, including an offline HTML report. However, it omits important traits such as whether an existing directory is overwritten, whether writes are additive, and any permission or failure behavior for a mutation 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?

A single front-loaded sentence states the action first, then enumerates outputs. It is efficient and waste-free, though the long artifact list is somewhat dense and could be trimmed to the most distinguishing files.

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-required-parameter tool with no output schema, the description usefully enumerates what gets written to disk, which compensates for the missing return documentation. It falls short only on behavioral caveats (overwrite handling, session requirements) that an agent would want before invoking a write 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 100%, so all nine parameters (dir, name, maxRows, rootDir, and the five include* toggles) are already fully documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description pairs a specific action (把抓到的全部内容落盘, persisting captured content to disk) with an exhaustive enumeration of the resulting artifacts (session.json, network.har, dom.html, report.html, manifest.json, etc.). This makes it unambiguous against siblings like capture_stop (which halts), capture_list_saved (which lists), or network_list (which reads), so an agent can tell what this produces without opening a schema.

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 statement of when to invoke this versus alternatives such as capture_stop or capture_list_saved, nor any prerequisite (e.g. an active session, completed capture). Usage is only weakly implied by '抓到的内容' (the captured content). No exclusions or routing guidance 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?

With no annotations, the description carries the full behavioral burden and does disclose a meaningful side effect: the buffer is cleared, which destroys any previously captured console/network/error data. It also defines the capture scope and the timestamping behavior. It omits what happens if a capture is already running and any permission/session requirements.

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

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

A single dense sentence with the destructive buffer-clear front-loaded and the scoping clause second. No filler, nothing repeated from the title.

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-required-param lifecycle starter with no annotations and no output schema, the description covers side effects and capture scope adequately. Remaining gaps (re-invocation behavior, interaction with capture_stop/status, return value) are minor given the tool's simplicity.

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

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

Schema description coverage is 100%, so targetId's meaning ('optionally switch to that tab') is already fully documented in the schema. The description adds no additional parameter detail, which matches the baseline of 3 when the schema does the heavy lifting.

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

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

The description names a concrete verb and resource: it begins a capture round, clears the buffer, and stamps a start time. It is clearly the initiator of a capture lifecycle, but it never distinguishes itself by name from the closely related capture_status/capture_stop (or recording_start) 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?

Usage is only implied by '之后发生的...都会被计入本轮抓取' – the agent can infer it should be called before the activity it wants recorded. There is no explicit statement of when to use this versus capture_status, capture_stop, or the overlapping recording_start, nor any prerequisite (e.g. session/target requirement).

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. It discloses the inspected state (buffer count, target page, in-round flag), which implies a read-only probe, but never states explicitly that it has no side effects, nor whether it is scoped to the current session only.

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

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

A single front-loaded sentence covering all three returned facts with zero filler. Nothing redundant or misplaced.

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

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

There is no output schema and no annotations, so the description must carry both the return-shape and safety burden. It names the three returned facts but does not describe the shape of the response (field names, units of the buffer count) or the non-mutating nature of the call.

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 takes zero parameters, so there is nothing for the description to clarify beyond the schema. Baseline 4 applies; the description correctly implies the call needs no arguments.

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 inspection purpose and enumerates exactly what is read: buffer count, target page, and whether a capture round is active. That is specific enough to distinguish it from capture_start/capture_stop, though it never names those siblings or session_info to disambiguate similar status reads.

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 when-to-use guidance, no prerequisites, and no reference to the sibling capture_start / capture_stop / capture_list_saved tools. The agent must infer that this is a non-mutating poll used before or during a capture round.

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 usefully discloses the non-persistent behavior ('不落盘') and the return content, but says nothing about prerequisites (must a capture be running?), error/empty conditions, or what the returned summary contains operationally.

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?

One short sentence with the primary action front-loaded, followed by the persistence caveat in a parenthetical. Nothing is wasted and the key differentiator is not buried.

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, no output schema, and four undocumented parameters, the description is only partially sufficient: it explains scope and persistence but leaves both the parameter meanings and the nature of the returned 'suggestion summary' unexplained.

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

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

All four boolean parameters (includeDom, includeStorage, includeScreenshot, includePerformance) have 0% schema description coverage and are completely unmentioned in the description. The agent cannot learn from either source what toggling these flags changes in the returned statistics.

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 and resource ('结束当前这一轮抓取') plus the return payload ('统计与建议摘要'), and explicitly names the sibling it is not ('要落盘用 capture_save'). An agent can separate it from capture_start/capture_save/capture_status without opening any schema.

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?

Gives one explicit routing rule: use capture_save when persistence is required. It implies usage after a capture round, but never says when to prefer this over capture_status or what state (an active capture) must hold before calling.

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

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

With no annotations, the description carries the full burden. It usefully discloses the blast radius (session buffer only, persisted artifacts untouched), which is real behavioral value, but says nothing about reversibility, whether the clear is immediate, or any return signal.

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

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

A single front-loaded sentence with no filler; the scope qualifier is attached directly to the action it modifies.

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, no-output tool with no annotations, the description covers what is affected and what is not. Only the post-clear state (empty buffer, irreversibility) is left unstated, a minor gap.

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

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

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate.

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+resource: clearing console data buffered in the current session. The parenthetical scoping clause distinguishes it from a broader purge affecting persisted artifacts, though it does not explicitly name siblings like console_read or network_clear.

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

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

Usage is implied by the scope statement — this clears the in-session console buffer rather than stored output — but there is no explicit when-to-use guidance, no prerequisites, and no named alternative to compare against.

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 burden. It does disclose that output is already captured rather than live, and lists filter capabilities, but says nothing about pagination, return shape, or side effects.

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

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

Two short sentences, front-loaded with the core action and followed by filter capabilities and use cases. No sentence is wasted.

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 schema fully documents all optional parameters, so the description does not need to repeat them. However, with no output schema, it leaves the return format and pagination behavior unexplained, which limits completeness for an agent invoking the tool.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema. The description adds a useful summary of filter categories but no syntax or default-value details beyond what the schema provides.

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

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

The description states a specific verb and resource: reading already-captured console output, with supported filter dimensions. It is clearly distinct from console_clear by implication, but does not explicitly differentiate itself from siblings such as page_errors.

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 usage context: troubleshooting errors and locating log sources. It does not state when not to use it or name alternative tools for similar needs.

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 it does disclose what each listed subscription reports (filter, matched count, buffer count, cursor), which is genuinely useful behavioral context. It stops short of stating read-only semantics, whether subscriptions are live/active, or whether the listing is paginated.

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

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

A single front-loaded sentence with zero filler; every clause names a concrete returned attribute and nothing is repeated from the title or schema.

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?

Because there is no output schema, the enumeration of returned fields is the right thing to include and partially compensates. But with no annotations and no usage guidance, an agent still lacks the safety profile and the selection criteria needed to confidently choose this tool over its events_* siblings.

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

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

Schema description coverage is 100% and the single parameter (includeHidden) is fully documented in the schema with a default. The description adds nothing about the hidden/internal-subscription distinction, so the schema does all the work — baseline 3 applies.

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

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

States a specific verb+resource ('列出所有订阅') and even enumerates the fields surfaced for each subscription (filter conditions, matched count, buffered count, cursor). It does not, however, distinguish itself from adjacent siblings like events_read or events_subscribe, so an agent must infer the boundary.

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 when-to-use guidance, no mention of prerequisites, and no naming of alternatives such as events_read or events_unsubscribe. The description only says what it returns, leaving selection among the four events_* siblings entirely to inference.

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. It usefully discloses the core non-blocking trait ('不等待', reads already-accumulated events), but says nothing about subscription validity requirements, the return shape of a 'snapshot', or behavior when no events exist.

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

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

Two tight sentences with the non-blocking core behavior front-loaded and the usage hint second. No waste, though it is arguably terse enough to leave gaps rather than being fully economical.

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 4-parameter read tool with no output schema and no annotations, the description covers the key non-blocking behavior but omits return-format expectations, what happens on an invalid/unknown subscription, and the meaning of includeFrameData. Adequate but with visible gaps.

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

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

Schema description coverage is only 50%: limit and cursor are documented in the schema, while subscriptionId and includeFrameData are documented in neither. The description adds no parameter-level meaning at all, leaving half the parameters (including the undocumented includeFrameData) unexplained.

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

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

The description states a specific verb (立即读取, read immediately) plus resource (订阅里已积累的实时事件, accumulated real-time events in the subscription) and explicitly contrasts with the blocking behavior of its sibling events_wait via '不等待'. An agent can distinguish this from events_wait without opening either schema.

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 second sentence gives clear when-to-use context ('适合先看一眼再决定是否阻塞等待'), effectively pointing to events_wait as the blocking alternative. It stops short of naming the alternative tool explicitly, so it is strong but not fully spelled out.

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

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

With no annotations, the description carries the full burden. It usefully discloses the return value (subscriptionId) and that events arrive immediately, but it omits lifecycle behavior such as auto-unsubscribe, buffer limits, and the push/notification fallback to polling (which live only in the schema). No auth or rate-limit context is provided.

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

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

Two sentences, front-loaded with the core action and scope, then the return/consumption workflow. The enumeration of event types is somewhat long but earns its place by defining scope; no filler.

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

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

For a no-output-schema, 11-param subscription tool, the description supplies the critical missing piece (it returns subscriptionId and how to consume it) plus the event scope. It is fairly complete, though it leaves auto-unsubscribe/buffer semantics and push fallback to the schema rather than surfacing them.

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

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

Schema description coverage is 100%, so the schema already documents all 11 params (push, level, buffer, frames, channels, etc.). The description adds only a general list of what events exist, which maps loosely to the channels enum but adds no syntax or format detail beyond the schema baseline.

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

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

States a specific verb and resource ('订阅实时事件流') and enumerates exactly what flows in (console, network, error, navigation, target, metric, frame). It also names the sibling tools used to consume the subscription, so an agent can distinguish this from events_read/events_wait.

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 defines the workflow clearly: subscribe here, then consume via events_wait (blocking) or events_read (immediate), which effectively routes the agent across siblings. However, it gives no explicit comparison against alternative event-acquisition tools such as recording_start or the individual console_read/network_list/page_errors readers, nor any when-not guidance.

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

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

No annotations are provided, so the description carries full behavioral burden. It usefully discloses side effects beyond the schema: releasing buffers and automatically stopping unused performance sampling and screen streaming. However, it omits permissions, idempotency, error behavior, and whether the subscription ID must be active.

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

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

Two short sentences, front-loaded with the core action and followed by a relevant side-effect note. No wasted wording, and the essential behavior is conveyed immediately.

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 mutation tool with no annotations or output schema, the description covers the core action and key side effects. It is not fully complete because it lacks usage context and parameter semantics, but it does enough to support correct invocation.

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

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

Schema description coverage is 0%, so the description should compensate for the undocumented subscriptionId parameter. It does not explain the parameter's format, source, or meaning beyond the implicit association with '订阅'; the schema only declares it as a required string.

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 and resource: '结束订阅并释放缓冲' clearly identifies the tool as ending a subscription and releasing its buffer. It contrasts implicitly with the sibling events_subscribe, but does not explicitly name alternatives or distinguish itself from other event-related 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?

No explicit guidance on when to use this tool versus alternatives such as events_subscribe or events_read. Usage is only implied by the phrase '结束订阅', leaving the agent to infer the correct context without any when-not conditions.

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

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

With no annotations, the description carries the burden and does well: it discloses the blocking long-poll semantics, immediate return on match, the timeout default of 15s and the 120s ceiling. It stops short of stating what happens on timeout (empty result vs error), which would be the last useful behavioral detail.

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

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

Three compact clauses with zero filler, front-loaded with the mechanism, then the timeout bound, then cursor semantics. Every sentence earns its place.

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

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

No output schema exists, so the description should hint at returns; it partially does via 'the cursor returned last time', implying a cursor in the response. It does not describe the event payload shape or the timeout-return behavior, leaving a modest gap for a polling 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 100%, so the schema already documents all six parameters and the baseline is 3. The description adds value beyond the schema by noting the 120s cap on timeoutMs (schema only lists the 15000 default) and by explaining the no-loss/no-duplicate guarantee of cursor resumption.

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 mechanism and resource: long-polling wait for matching real-time events, returning immediately on arrival. Clear verb+resource, but it does not explicitly contrast itself with the sibling events_read, which an agent must choose between.

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 '这是任何客户端都能用的实时消费方式' implies a general-purpose consumption path, and cursor handling hints at sequential polling, but the description never states when to prefer this over events_read or events_list. Usage is implied rather than spelled out.

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 disclosure burden. It usefully discloses that the returned content is text and that binary payloads must be judged by the caller (via mimeType) for base64 handling. However, it omits behavior an agent needs: what happens when the body is unavailable or evicted, whether the response is truncated by maxChars, and any permission or session-state requirements.

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

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

Two short sentences with no filler, and the core purpose is front-loaded before the binary-response caveat. The mimeType reference is the only mildly confusing element in an otherwise tight definition.

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

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

With no annotations and no output schema, the description must carry more weight than it does. It covers the essence of the return (text body plus a binary caveat) but leaves gaps around requestId provenance, truncation behavior at maxChars, and failure cases for unavailable bodies.

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 only 50%: maxChars is documented in the schema (default 20000) but requestId has no schema description, and the tool description does not explain where requestId comes from or its expected form. The description also references mimeType, which is not a parameter of this tool at all, adding confusion rather than semantic 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?

The description names a specific verb+resource: retrieve the response body (text) of a specified request. It is clearly distinct from network_list and network_clear, though it never explicitly contrasts itself with the closest sibling, network_detail. An agent can infer the purpose but must assume the relationship to network_detail.

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 when-to-use guidance: no statement that requestId comes from network_list/network_detail, no prerequisites, no indication of when to prefer network_detail instead. The only conditional advice concerns binary responses and base64, which is a handling note rather than a tool-selection rule.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose the key scoping fact – only records in the current session buffer are destroyed – but omits that the operation is irreversible, whether it affects an in-progress capture, and whether a count or confirmation is returned.

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

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

A single short sentence that front-loads the verb and scope with zero filler. Nothing redundant or padded.

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, no-output-schema utility, the description covers what is cleared and where. The only meaningful gap is the absence of any warning that the clear is destructive and unrecoverable in an environment with no annotations to signal this.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly implies no arguments are needed.

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 (清空/clear) and a precise resource (当前会话缓冲的网络请求记录 – network request records buffered in the current session), which is distinct from siblings like network_list or network_detail. It does not explicitly name the complementary tools, but the action is unambiguous from name plus description.

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

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

There is no guidance on when to call this versus alternatives such as console_clear, nor any prerequisites or caution about clearing after a capture. Usage is only implied by the verb.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the payload it returns (headers, response headers, Post body, timing, initiator, cookie), but says nothing about read-only/side-effect-free nature, permissions, or whether full bodies are always available versus truncated.

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

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

A single sentence that front-loads the keying parameter and then lists the returned information. No filler, nothing to trim.

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 single-parameter read tool with no output schema, the description's field enumeration covers what an agent needs to decide the retrieval is worthwhile. It stops just short of stating read-only behavior or body-size caveats.

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

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

Schema description coverage is 100%, and the schema already explains that requestId is a CDP requestId obtainable from network_list. The description merely restates '按 requestId' without adding format or constraint detail, so the baseline 3 applies.

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

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

The description names a specific verb and resource ('按 requestId 查看单个请求') and enumerates the retrieved fields (headers, body, timing, initiator, cookie), which lets an agent distinguish it from network_list. It does not explicitly contrast with the closest sibling network_body, whose 'Post body' content overlaps with what this tool claims to return.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternatives. The only routing hint ('可用 network_list 获取') lives in the input schema, not in the description, so the description itself supplies no usage context.

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

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

With no annotations, the description must carry the full behavioral burden. '捕获到的' implies data comes from an active capture, and it discloses the available filter modes including failure/4xx/5xx subsets, which is useful context. However, it omits pagination behavior, default limits, and return shape for a 9-parameter read 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?

A single well-formed sentence with the core action front-loaded and filters enumerated efficiently. No wasted clauses, though it leaves useful detail unstated.

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 9-parameter tool with no annotations and no output schema, the description covers the main filter parameters but is silent on time-range (since), result cap (limit), and pagination. Adequate but with clear gaps for an agent to call it precisely.

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

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

Schema description coverage is 89%, so the schema already documents nearly every parameter. The description restates the filter dimensions (URL, method, type, status, failure flags) but adds no format or syntax detail and never mentions limit, since, or targetId. Baseline 3 applies when schema does the heavy lifting.

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

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

States a specific verb ('列出' / list) and resource ('网络请求' / network requests), and the filtering scope is described concretely. It implicitly separates itself from sibling network_detail (single request) and network_clear, but does not name any sibling explicitly.

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 what can be filtered but gives no guidance on when to choose this over network_detail, network_body, or network_clear. No prerequisites (e.g. that a capture must be running) or exclusions are 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 carries the full behavioral burden. It does disclose two useful traits beyond the schema: the default is 'both' and overly long HTML is automatically truncated. However, it omits whether this is a pure read, any permission/context requirements, and what truncation actually does to the returned payload.

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

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

A single dense sentence front-loads the resource, then lists the output modes and the two behavioral facts (default 'both', auto-truncation). Nothing is wasted and the key information comes first.

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

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

For a 6-parameter, no-required-args read tool with no output schema and no annotations, the description is adequate on purpose but thin on behavior: it does not characterize the returned payload shape, how truncation is signaled, or any relationship to sibling capture tools. Parameters themselves are fully covered by the schema.

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

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

Schema description coverage is 100%, so every parameter (mode, depth, maxNodes, skipHidden, maxHtmlChars, maxTextLength) is already documented with its default in the schema. The description only restates the mode default and truncation behavior, adding no syntax or interaction detail beyond the structured fields — the expected baseline.

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

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

The description states a specific verb and resource ('获取当前页面的 DOM') and enumerates the three output modes (raw HTML, LLM-friendly indented outline, or both), so the agent knows exactly what this returns. It does not, however, differentiate itself from nearby siblings like page_evaluate or page_screenshot.

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 when-to-use or when-not-to-use guidance. The phrase '适合 LLM 阅读的缩进结构大纲' implies the outline mode exists for LLM consumption, but the description never says when to prefer this over page_evaluate, page_screenshot, or network_body, nor does it state any prerequisites.

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

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

With no annotations, the description carries the behavioral burden and does disclose the aggregating nature and the returned fields (URL and call stack). However, it omits ordering/recency, whether results reflect a live session or persisted capture, deduplication, and pagination behavior. Useful surface, but not full 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?

A single tight sentence with no filler, and the core content (what error types are captured) is front-loaded. Efficient for the complexity level.

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 low-complexity, one-optional-param read tool with no output schema, the description is adequate about content but silent on ordering, session scope, and how to interpret or page results. Minimum-viable rather than complete.

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

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

Schema description coverage is 100% and the single optional limit parameter is already documented as '最多返回条数，默认 100'. The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

The description names a specific verb (列出) plus the resource (errors) and enumerates the sources it aggregates: uncaught exceptions, console.error, log errors, and renderer crashes. It is clear what the tool returns. It does not explicitly distinguish itself from the sibling console_read, which also surfaces console output, so it stops short of a 5.

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

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

No guidance on when to use this instead of console_read, console_clear, or events_read is given. There is no mention of live vs. historical scope, retention, or exclusions. The agent must infer eligibility from the sibling list alone.

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

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

No annotations are provided, so the description carries the full burden. It usefully equates the tool to the DevTools Console, which conveys full page-context access and mutation capability, but it says nothing about side effects, destructive potential, serialization limits, or sandboxing. Given arbitrary code execution is possible, this is a meaningful gap.

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

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

A single, front-loaded sentence that states action, context, return behavior, and the mental model (DevTools Console). Every clause earns its place 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?

With no annotations and no output schema, the description must carry more weight. It adequately describes what happens for the happy path (returns result, supports await) but omits serialization behavior tied to returnByValue, failure modes, and safety implications of running arbitrary JS in the page context.

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

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

Schema description coverage is 100%, so all three parameters (expression, awaitPromise, returnByValue) and their defaults are already documented in the schema. The description's mention of await Promise support is already captured by the awaitPromise parameter, so it adds no new meaning beyond the schema.

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

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

States a specific verb (执行/execute) and a specific resource (JavaScript in the current page context), plus the return behavior and await support. No sibling tool shares this purpose, so the agent can immediately tell it apart from page_dom, storage_read or console_read.

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 DevTools Console equivalence implies when the tool is appropriate, but there is no explicit when-to-use or when-not-to-use guidance relative to alternatives like page_dom or console_read. Usage is left to inference from the stated purpose.

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

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

With no annotations, the description carries the full burden. It usefully discloses the non-obvious default that base64 payloads are suppressed because of size, which is the single most important behavior here. It does not state what is returned when returnBase64 is false (a reference, a saved file, a truncated payload?), nor any permission or side-effect considerations, so the disclosure is partial.

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

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

Two short sentences, zero padding, and the critical default-and-override pair is front-loaded exactly where the agent needs it. Nothing is repeated that the schema already covers verbatim.

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 5-parameter tool with no annotations and no output schema, the description omits the return shape: an agent cannot tell what comes back when returnBase64 is false, which is the default path. The tool is simple enough that this is a moderate rather than fatal gap, but the default outcome is left undefined.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces returnBase64 with a rationale ('图片数据默认不回传（体积大）') that the schema only states tersely, but it adds nothing for format, quality, fullPage, or maxBytes, which remain schema-only.

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+resource ('对当前页面截图' – screenshot the current page), which is unambiguous about what the tool produces. However, it never distinguishes itself from the many sibling tools in the capture/recording family (capture_start, capture_stop, capture_save), leaving the agent to infer how page_screenshot differs from them.

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

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

It gives one concrete usage rule: image data is not returned by default, so set returnBase64=true when you actually need to see the image. That is real conditional guidance, but there is no when-to-use/when-not-to-use framing against alternatives or any precondition (e.g., a page must be loaded/selected first).

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

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

With no annotations present, the description carries the full behavioral burden, yet it only lists the metrics returned. It does not state that this is a safe read-only operation, whether it perturbs the page, what it costs to call, or what the response shape looks like.

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

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

A single front-loaded sentence with no filler. Every clause enumerates a distinct metric class, so nothing could be cut without losing 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?

For a zero-parameter, annotation-free read tool with no output schema, the description covers what is returned but not the return format, units, or nesting of the metrics. It is adequate but leaves the agent guessing about response structure.

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 takes zero parameters, so there are no argument semantics to document; baseline 4 applies. The description correctly spends its text on output content instead of inventing 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?

Names a specific verb (获取/get) and enumerates the actual resources fetched: Performance.getMetrics metrics, navigation timing, paint timing, and JS heap usage. This clearly distinguishes it from siblings like page_screenshot or network_list, though it never explicitly contrasts itself with any of them.

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

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

No guidance on when to call this versus other diagnostics tools (page_errors, console_read, network_list). Usage is only implied by the tool name and metric list; there are no preconditions, alternatives, or exclusions.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose meaningful behavior: append-only JSONL with one event per line, memory-safe for long sessions, and ordered frame persistence. It omits overwrite/append semantics for pre-existing files and any permission requirements, leaving some gaps.

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

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

Two dense, front-loaded sentences plus a short routing clause; the core behavior (append JSONL) leads, the secondary feature (frames) follows, and the hand-off to recording_stop closes it with no filler.

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

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

For a six-parameter, no-output-schema tool with no annotations, the description covers the essential mechanics and points to recording_stop for results. Remaining gaps are minor: file naming/collision behavior and concurrency expectations are not addressed, but the agent can call 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 100%, so all six parameters (dir, name, rootDir, channels, saveFrames, performanceSampleMs) are already documented in the schema. The description only loosely gestures at channels and frames, adding no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a precise verb+resource: continuously appending the live event stream into a JSONL file, with optional ordered frame image saving. This is distinguishable from disk-unrelated siblings like events_subscribe or capture_start because the description emphasizes sustained disk-backed logging rather than one-off 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?

Gives a clear usage context ('suitable for long-running monitoring without memory blowup') and names the terminating companion tool, recording_stop, for stats. It does not, however, state when to prefer this over capture_start or events_subscribe, so alternatives are left implicit.

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 does disclose that statistics and artifact paths are produced on stop, which is useful behavior beyond structured fields. However, it says nothing about whether a partially completed recording is persisted, whether the call is idempotent, or what happens when no recording is active.

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

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

A single, front-loaded sentence with no filler. It is appropriately sized for the operation, though slightly terse given the absence of annotations.

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

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

Since no output schema exists, the description helpfully previews the return content (statistics and artifact paths). But for a stop/mutation operation with zero annotation coverage, it omits error conditions and side effects, leaving meaningful gaps.

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

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

Schema description coverage is 100%, and the schema already explains the recordingId semantics including the 'omit to stop all' behavior. The description adds no parameter-level detail, so the baseline 3 applies.

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

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

The description names a specific verb and resource ('结束实时录制' – end live recording) and states the outcome ('输出统计信息与产物路径'). It is clearly distinct from recording_start, but it does not distinguish itself from the nearby capture_stop sibling, leaving the recording-vs-capture boundary implicit.

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 when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (capture_stop, recording_start). An agent must infer from the sibling list whether this is the correct stop tool for a given capture session.

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

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

With no annotations, the description carries the burden and delivers real behavioral detail: automatic UTF-8 correction to avoid mojibake in Chinese text, and base64 output for binary media. It does not mention permissions, truncation side effects beyond maxChars, or error behavior, but the encoding/binary disclosure is genuinely useful 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?

Three short sentences, front-loaded with the core action, then the encoding caveat and the binary return behavior. Every sentence conveys distinct information with no filler.

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

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

For a read-only fetch tool with no output schema and no annotations, the description covers the return shape (text vs base64) and encoding handling. It leaves error and permission behavior unstated, but the essentials an agent needs to call it correctly are present.

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

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

Schema description coverage is 100%, so url, asBase64, and maxChars are already documented. The description echoes the base64 behavior for binaries but adds no syntax or format detail beyond what the schema states, so the baseline of 3 applies.

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

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

States a specific verb and resource (read page resource content by URL) and clarifies scope with a concrete analogy, likening it to opening a file in the DevTools Sources panel. This clearly separates it from siblings like resources_list or network_list, which enumerate rather than fetch content.

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

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

Usage is implied through the analogy (fetch a known resource's body) and the schema points to resources_list/network_list as URL sources, but the description itself gives no explicit when-to-use versus alternatives such as network_body or page_dom. An agent must infer the distinction.

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 the tree shape, the frame-based grouping, the resource categories covered, and the cross-referenced requestId/status/size fields, plus the important nuance that items may not appear in the Network buffer. It stays silent on ordering, size limits, or cost of the call, which keeps it short of a 5.

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

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

Two sentences, front-loaded with what is returned and then the complementary relationship. Every clause carries information; nothing is redundant.

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 output schema and no annotations, the description compensates by describing the return structure (per-frame tree with resource entries carrying requestId/status/size). That is enough for an agent to call it correctly and interpret the result, though pagination and result-size behavior remain unstated.

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

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

Schema description coverage is 100% and the single parameter targetId is already documented there. The description adds no further detail about the parameter (defaults, scope, format), so the schema does the work and the baseline 3 applies.

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

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

States a specific verb and resource: returns the DevTools Sources > Page tree, layered by frame, listing all page-loaded resources (documents, stylesheets, scripts, images, fonts, media). It explicitly distinguishes itself from the sibling network_list, so an agent can select it without opening the schema.

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 names network_list as the alternative and gives the condition that selects between them (page-resource perspective vs HTTP-request perspective, including resources that entered the page but may not be in the Network buffer). It doesn't route against resources_get, the obvious detail sibling, so the guidance is clear but not complete.

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

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

With no annotations, the description carries the full burden. It usefully discloses that nothing is written to disk and that the return shape is CapturedData, but is silent on whether the buffer is cleared after the dump, size/rate limits, or permissions.

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

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

A single sentence with the purpose front-loaded, followed by the key constraint and the use-case. Zero 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?

For a 4-parameter tool with no annotations, no output schema, and 0% parameter coverage, the description leaves the four include flags unexplained and the buffer-lifecycle semantics unaddressed. It is not complete enough for an agent to invoke confidently.

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

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

Schema coverage is 0% and all four boolean flags (includeDom, includeStorage, includeScreenshot, includePerformance) are entirely undocumented in both schema and description. The phrase '全部数据' (all data) arguably conflicts with the selective-include flags, adding confusion rather than clarity.

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+resource: returns the current buffer's data as a CapturedData structure, and clarifies it does NOT persist to disk. This distinguishes it from capture_save-style siblings, though it never names that sibling explicitly.

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 a clear conditional use case ('适合你想自己加工时用') and implies a contrast with disk-saving tools ('不做落盘'). No explicit when-not or named alternative, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full burden. 查看 implies a non-mutating read, and the enumeration of returned fields gives some behavioral picture, but there is no statement about side effects, permissions, or whether this reflects live state versus a snapshot.

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

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

Two short sentences with no filler, and the core purpose is front-loaded before the usage hint. Efficient, though the second sentence is more colloquial than informative.

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 usefully compensates by listing what is returned (connection info, target page, buffer counts, alerts). For a zero-parameter read-only diagnostic that is largely sufficient; a note on freshness or live-vs-cached state would complete 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 tool takes zero parameters, which sets the baseline at 4. There is nothing for the description to clarify beyond confirming it is a no-argument call.

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 (查看) and resource (当前会话), and enumerates the concrete contents it reports: connection info, target page, buffer counts, alerts. An agent can tell it apart from target_list or capture_status. It lacks an explicit contrast with siblings, so it does not reach 5.

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

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

The phrase 常用于判断"现在到底连着谁" implies a diagnostic usage context, but no alternatives (target_list, browser_list_processes, session_dump) are named and there are no when-not conditions. Usage is implied 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses a scope limit — IndexedDB is exposed only as database names, not record contents — but says nothing about cross-origin/iframe restrictions, permissions, or whether writes are involved (it is read-only by implication of 读取).

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

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

A single front-loaded sentence that names the action and then enumerates the covered stores. Every clause earns its place, with no preamble or filler.

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

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

For a parameterless read tool with no annotations and no output schema, the description adequately names what is retrieved, and the IndexedDB-names caveat pre-empts a wrong expectation about return depth. It could say slightly more about the shape of what comes back, but it is substantially complete.

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

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

The tool takes zero parameters and the schema is empty, so there is no parameter semantics to clarify; the baseline for a parameterless tool is 4. Nothing in the description misleads about 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 specific verb (读取/read) and resource (页面存储/page storage) and enumerates exactly which stores are covered: Cookies, localStorage, sessionStorage, and IndexedDB database names. No sibling overlaps with this scope, so an agent can select it without ambiguity.

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

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

The description never states when to reach for this tool versus adjacent read tools such as console_read, network_list, or page_evaluate. There are no prerequisites, exclusions, or alternatives mentioned.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it delivers real behavior: results are filtered by default, background targets (extension pages, service workers, devtools) are hidden, and the filter is what causes the visible/count discrepancy on Edge/Chrome with extensions. It stops short of stating return shape or permissions, which keeps it out of 5 territory.

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

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

Two sentences, zero filler: the default behavior is front-loaded, the rationale follows, and the override instruction closes. Every clause earns its place.

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

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

For a single optional-boolean list tool with no output schema or annotations, the description covers the key decision (default filter vs. includeBackground) and the practical reason for it. It could add a hint about what a listing entry contains, but that is minor given the tool's simplicity.

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

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

Schema coverage is 100%, so the baseline is 3, but the description goes beyond the schema by explaining why the boolean exists – the volume of noisy extension/service-worker targets – which helps an agent decide when to set it. That is meaningful added context over the schema's terse field description.

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

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

States a specific verb (列出) and resource (当前浏览器中可附加的页面), and the scope phrase '可附加的页面' distinguishes it from siblings like browser_list_processes and target_select. An agent can tell what it enumerates without opening the schema.

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 clearly explains when to flip includeBackground to true (when you need the full target set rather than the filtered view). It doesn't name an explicit alternative tool for attaching to a target, but the use context is unambiguous for a list operation.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose the key trait: this is a stateful selection whose effect persists across subsequent console/network/DOM calls. It does not say whether the previous attachment is released, whether it is session-scoped, or how invalid IDs fail, so it is 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?

One sentence, front-loaded with the action, then the consequence. Nothing is redundant and every clause earns its place.

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

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

For a one-parameter, annotation-free selection tool with no output schema, the description conveys purpose, the state change, and its downstream effect. Missing only edge-case behavior (invalid ID, prior attachment) to be fully complete.

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

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

Schema description coverage is 100% and the single targetId parameter is documented in the schema with the pointer to target_list. The description adds no syntax, format, or example detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource (attach to a tab and make it the current capture target) and immediately differentiates itself by naming the scope of downstream tools it affects (console/network/DOM). An agent can distinguish it from target_list, which merely enumerates IDs, without opening either schema.

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

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

Implies when to use it: before invoking console/network/DOM tools, since those operate on whichever tab is selected. The schema points to target_list as the way to obtain an ID, so the prerequisite path is discoverable. It stops short of explicit when-not guidance or state about what happens if an ID is invalid.

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