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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses that the operation is destructive, requires both confirm: true on retry and a user press within 60s, and explains the needsConfirmation retry pattern. This is unusually complete for a destructive 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?

The description is front-loaded with purpose and destructiveness, then gives the confirmation protocol, then lists parameters. It is compact with no wasted sentences.

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 destructive tool with no annotations and no output schema, it provides enough context to invoke correctly: scope, destructiveness, confirmation prerequisites, retry behavior, and parameters. Missing return-value details are minor because no output schema exists.

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

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

Schema description coverage is 0%, so the description must add parameter meaning. It identifies area as required and confirm as boolean, and explains confirm's workflow, but it does not explain the area enum values (localStorage/sessionStorage) 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 states a specific verb and resource: clear an entire area (every key) for the active tab's origin. That scope implicitly separates it from selective siblings like delete_keys, but it does not explicitly name or compare against 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 clearly explains the intended use case—clearing all keys in a storage area—and gives the required confirmation workflow, including the retry and user-approval steps. It does not explicitly state when to use a sibling such as delete_keys instead.

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, yet it never says whether deletion is permanent/irreversible, what happens to keys that don't exist, or whether errors are raised. The origin-scoped targeting is useful behavioral context, but the destructive profile of a delete operation goes undisclosed.

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 the purpose front-loaded and no padding. The second sentence is largely redundant with the schema, which keeps it from a 5.

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 zero schema description coverage, the description should cover irreversibility, missing-key behavior, and what is returned (e.g., count deleted). It covers none of these, leaving an agent under-informed for a destructive 2-param 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 0%, so the description must compensate, but it only restates that area and keys are required — information already in the schema's required array and enum. Nothing explains key format, duplicate handling, or behavior for absent keys.

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 (delete keys) plus the storage areas and the origin scope, which clearly separates it from clear_area (whole-area wipe) and write_storage. It never names those siblings explicitly, so the differentiation is inferable rather than stated.

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 origin/tab scoping implies when this applies, but there is no explicit guidance on when to prefer this over clear_area or list_storage_areas, and no stated prerequisites. Usage must be inferred from the verb alone.

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

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

With no annotations, the description carries the full burden and does well: it discloses the scope (active tab's origin), a meaningful privacy trait (cookie values always redacted), and that rawCookieValues is a no-op. It stops short of stating read-only semantics, permission prerequisites, or snapshot size limits.

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 payload contents and followed by the parameter caveat. No filler, and the most decision-relevant fact (redacted cookies, ignored param) 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?

Without an output schema, the description usefully enumerates the returned fields (origin, localStorage, sessionStorage, cookie metadata), so the agent knows what comes back. Minor gaps remain around permissions needed for the active tab and the response shape (object vs. file download).

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

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

Schema description coverage is 0%, so the description must compensate entirely for the single parameter, and it does: rawCookieValues is called out as boolean, ignored, and retained only for compatibility, preventing the agent from believing it changes behavior.

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 (export) and resource (storage snapshot of the active tab's origin) and enumerates the four data classes included, which implicitly distinguishes it from the narrower read_storage/read_cookies siblings. It never names those siblings explicitly, 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?

Usage is implied by 'active tab's origin' and the aggregate 'snapshot' framing, suggesting it is the one-shot alternative to piecemeal reads. However, there is no explicit when-to-use or when-not-to-use guidance relative to read_storage, read_cookies, or list_storage_areas.

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 and no output schema, the description carries the full burden. It partially meets it by saying what is returned and adding the safety guarantee 'No secrets,' which tells the agent it won't leak credentials. It omits failure behavior (what happens with no active target) and does not explicitly state that the call is a side-effect-free read.

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 the resource and returned fields front-loaded; no filler. The 'No secrets' fragment is terse but earns its place as a privacy note.

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 read tool the description covers what the agent gets back, which is the main thing. It is incomplete on error/edge behavior and read-only guarantees, which matter because no annotations or output schema supply that context.

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

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

The tool has zero parameters, so the baseline is 4. The description adds nothing extra because nothing about parameters needs explaining.

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 ('Describe') and resource ('the active target the agent is operating on') and enumerates the fields returned (tab id, URL and origin, title). That clearly distinguishes it from the storage/cookie siblings, though it never explicitly contrasts itself with 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?

Usage is only implied: an agent would infer it should call this to learn what page it's on. There is no explicit statement of when to use this versus the storage-reading siblings, nor any exclusion or precondition.

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. 'List' implies a safe read operation, and the description discloses the returned inventory fields, but it does not explicitly state side-effect behavior, permissions, or whether a target must already be selected.

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 action and enumerates the key return contents without any 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?

With no output schema, the description usefully names the returned information (origin, storage areas, IndexedDB database names). For a simple no-parameter discovery tool, this is nearly complete, though it could clarify whether the target must be set first.

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

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

The tool has zero parameters, so there are no parameter semantics to document. The description correctly does not invent parameters, and the baseline for a no-parameter tool is 4.

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

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

The description uses a clear verb ('List') and specifies the resource as what the bridge can operate on for the current target. It also names key returned data, which helps distinguish it from content-reading siblings like read_storage, though it does not explicitly name alternatives.

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 'for the current target' implies usage as a discovery/inventory step, but there is no explicit guidance on when to use this versus get_target, read_storage, or read_indexeddb. Usage is inferable but not stated.

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

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

With no annotations, the description carries the full disclosure burden and does well: it reveals the non-obvious privacy gate (values redacted to "<redacted>" without explicit user consent) and that the call still succeeds without consent. It omits permission requirements and any limits on how many cookies are returned, keeping it just 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, zero waste: the scope and return fields come first, then the one parameter's semantics and its consent caveat. Nothing is repeated from structured fields and nothing extraneous is included.

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?

A read tool with one optional param, no output schema, and no annotations; the description covers the resource scope, the return fields, and the consent behavior, which is nearly everything needed. Minor gaps remain around required extension permissions and any result-size or pagination behavior.

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

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

Schema coverage is 0% and the single parameter is undocumented in the schema, so the description must compensate — and it does, explaining that rawCookieValues is a boolean gate whose effect is redacted vs. raw values and that consent is required for raw values. It effectively implies the default (redacted) behavior.

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 all cookies') plus a clear scope ('visible to the active tab') and enumerates the returned fields (name, domain, path, secure, httpOnly, sameSite, session). It does not explicitly differentiate itself from siblings like read_storage or read_indexeddb, but the resource noun and tab-scoping make the distinction inferable.

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 the consent precondition for rawCookieValues, which is genuinely useful usage context, but it never says when to choose this tool over read_storage, read_indexeddb, or export_state. Usage is implied by the resource rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses pagination behavior, JSON-safe serialization, active-tab origin scoping, and limit defaults/maxima, but it does not state permissions, error handling, empty-store behavior, or the shape of returned records.

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

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

Two compact sentences, front-loaded with the core operation and followed by essential parameter semantics. There is no filler, and the default/max details earn their place because the schema does not document them.

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 tool with no output schema and no annotations, the description should more fully explain what is returned and how to continue paging. It implies nextCursor exists via the cursor parameter and gives good input semantics, but the return payload and edge-case behavior remain underspecified.

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

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

Schema description coverage is 0%, so the description must compensate and largely does: it marks db and store as required, explains cursor as a number offset from a previous call's nextCursor, and gives limit's default (200) and maximum (1000). The only gap is that db and store are not explicitly described as database and object-store names beyond their labels.

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: a cursor-paged, JSON-safe read of an IndexedDB object store on the active tab's origin. It is clearly distinguishable from write/delete siblings, though it does not explicitly name or contrast with read-only siblings such as read_storage or list_storage_areas.

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 phrase 'cursor-paged read' and the cursor parameter referring to a previous call's nextCursor, which suggests iterative paging. However, there is no explicit when-to-use guidance versus alternative read tools like read_storage, nor any stated exclusions or prerequisites.

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

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

With no annotations, the description must carry the full behavioral burden. It usefully discloses that the read is scoped to the active tab's origin and is non-mutating by implication, but says nothing about what is returned (key/value map vs list), ordering, or size/limit behavior when omitting both filters.

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 passage, front-loaded with the core action, then the parameter rules, with the cross-tool caveat in a trailing parenthetical. No sentence 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?

For a 3-param read tool with no output schema and no annotations, the description covers scope, parameter interaction, and sibling disambiguation adequately. The main remaining gap is the shape of the returned data, which the agent would have to discover empirically.

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

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

Schema coverage is 0%, so the description has to compensate and does: it marks area as required, explains key as a single key, prefix as all keys beginning with a prefix, and specifies that omitting both returns everything — including the mutual-exclusivity rule the schema never states.

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 keys from localStorage or sessionStorage') plus the scope ('of the active tab's origin'), which is information an agent cannot get from the schema. It also pre-empts the closest confusion by naming read_cookies as the wrong tool for cookies.

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 an explicit boundary against the sibling read_cookies and an in-tool rule for when to use key vs prefix vs neither. It does not say when reading storage is inappropriate versus list_storage_areas or read_indexeddb, but the routing it does offer is concrete.

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 load. It usefully discloses a side effect (every write is appended to the sidebar changelog so the user sees it) and the JSON-serializable string constraint, but says nothing about overwrite semantics for existing keys, permission/auth needs, or error behavior on a full quota.

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 action and scope, then params, then the notable side effect. No filler and nothing 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?

For a 2-param mutation tool with no annotations and no output schema, the description covers purpose, both parameters, and the user-visible changelog effect. The main gap is what happens when a key already exists or when storage is full.

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?

With 0% schema description coverage, the description compensates well: it marks area as required, names the two enum values implicitly, and expands the opaque `items: object` schema into `[{key, value}]` with values as JSON-serializable strings. Only the exact shape of the entry objects is left slightly implicit.

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 (write) and resource (entries into localStorage/sessionStorage) plus a precise scope (active tab's origin). This clearly separates it from read_storage, clear_area, and delete_keys without needing their schemas.

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

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

There is no explicit guidance on when to use this versus siblings like clear_area or delete_keys, and no stated prerequisites or exclusions. The scope phrase implies when it applies, but no alternative routing or when-not conditions are given.

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