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

It provides significant behavioral transparency by specifying the technical path to the accessibility front, which is not covered by annotations. It also explicitly defines the output as a 'bounded outline,' managing expectations about the return value.

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

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

The description is well-structured and concise, front-loading the core functional description. It uses technical detail where necessary but remains highly focused on the tool's unique capabilities.

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

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

Given that the tool interacts with a complex, internal DevTools accessibility front, the description is extremely complete by including the exact chain of commands required to access the required data.

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

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

The schema coverage is 100% for both `maxDepth` and `maxNodes`, meaning the schema provides all necessary semantic information. The description does not add additional semantic value beyond clarifying that these parameters manage the bounds of the accessibility walk.

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?

While the description is clear, it does not explicitly name alternative tools like `browser_dom_tree` to help the agent decide when *not* to use this specific accessibility walker. The usage guidance is implied rather than prescriptive.

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

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

The description provides highly valuable context for correct usage by detailing the required implementation path: `target.getFront("accessibility") then getWalker()`. This technical guidance is crucial for the agent's success in the execution environment.

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?

Adds genuinely useful measured behavior beyond readOnlyHint: about:processes renders asynchronously and may need a repeat call. It does not describe what happens when no matching about: page is open or how maxChars truncation manifests, which would round out the picture.

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 purpose first, then the empirically measured caveat. Nothing is repeated from the annotations or schema, and every clause carries 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?

With no output schema, the description does name the return content (title and visible text), and the async caveat covers the main failure mode. Edge cases such as an unopened or non-matching about: page are left unaddressed.

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 both page and maxChars are already documented with examples and bounds. The description's "visible text" wording mildly reinforces what maxChars controls but adds no format or syntax 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?

States a concrete verb and resource (report the title and visible text of an about: page) and the qualifier "already-open" implicitly separates it from browser_open_about_page. An agent can immediately tell this reads an existing page rather than creating one.

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 motive (confirm the internal page actually rendered rather than assuming) plus retry guidance after a short wait. It lacks an explicit "do not use for" clause or a naming of alternatives, but the context is unambiguous.

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?

readOnlyHint=false already flags a mutating call; the description goes further by explaining that only the main/primary action is triggered, that this is equivalent to a human click, and that the effect is a real decision such as accepting a password save. It doesn't cover failure behavior for stale/unknown ids or what the call returns, but it adds meaningful context beyond the annotation.

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: action, id source, and a behavioral analogy, with the core action front-loaded. 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 one-parameter mutating tool with no output schema, the description covers what it does, where the id comes from, and what the effect is. Nothing essential for correct invocation 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% and the single parameter's own description already points to browser_list_popup_notifications, so the description adds no new syntax or format detail. Baseline 3 applies since the schema does all the work.

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 ("press the main action of a doorhanger notification by id") and an example use case (accepting "Save password?"). It clearly distinguishes itself from browser_list_popup_notifications, but not from the adjacent browser_handle_prompt sibling, which an agent might confuse with this.

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

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

It explicitly tells the agent where the required id comes from (browser_list_popup_notifications), which is the key selection prerequisite. It does not, however, state when-not to use it or how it relates to browser_handle_prompt for generic dialogs.

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

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

The only annotation is readOnlyHint=false, which the description is consistent with, and it adds the important behavioral fact that subsequent input is routed to the active tab. However, it does not say what happens to the previously active tab, whether the window is raised/focused, or how an out-of-range index or stale context id is handled.

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 action and identifier sources come first, followed by the practical rationale. Nothing is redundant or 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?

For a two-optional-parameter state-change tool with no output schema, this covers what it does, how to identify the tab, and why it matters. Minor gaps around error/failure behavior and focus side effects keep it just short of 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 coverage is 100% and both parameters are already documented, including that index is an alternative to a context id. The description adds only provenance ('from browser_list_tabs'), so the baseline of 3 applies rather than a higher score.

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 ('Make a tab the active one') and even names the underlying API (browsingContext.activate). It is clearly distinguishable from siblings like browser_list_tabs, browser_new_tab, or browser_close_tab.

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 concrete use condition — call it before typing or clicking because input goes to the active tab — and points to browser_list_tabs as the source of the context id. It stops short of stating exclusions (e.g. when activation is unnecessary or fails), so it is strong but not fully 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?

Annotations already declare readOnlyHint=false and destructiveHint=true; the description adds value beyond that by naming the underlying PlacesUtils call, disclosing the default parent folder, and stating that a guid is returned. It does not cover edge behavior such as what happens when the URL is already bookmarked or on invalid guids, so it is not fully transparent.

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

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

Two sentences, both load-bearing: the first establishes action and return value, the second establishes default and alternative targeting. No filler or restated title text.

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 three-parameter, fully documented write tool with no output schema, the description covers action, default parent, targeting options, and the return contract (guid). It leaves duplicate-handling and failure behavior unstated, which is the only meaningful gap.

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

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

Schema coverage is 100%, so the baseline is a 3; the description earns above that by explaining the semantic effect of parentGuid (defaults to the bookmarks menu, alternate targets are toolbar and unfiled) rather than just restating its name. It omits the literal guid strings for toolbar/unfiled, leaving the agent to discover them from browser_bookmark_folder.

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 ("Insert a bookmark") plus the underlying API call, and distinguishes itself from the removal counterpart by noting the returned guid is what browser_remove_bookmark needs. An agent can tell this apart from browser_remove_bookmark, browser_list_bookmarks, and browser_bookmark_folder without opening 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?

Explicitly gives the default targeting behavior (bookmarks menu) and the condition for choosing otherwise (pass toolbar or unfiled guid), and explains the downstream use of the returned guid. It stops short of routing against other bookmark-management siblings such as browser_bookmark_manage or browser_bookmark_folder.

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

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

Annotations already flag this as non-read-only and destructive, so the description adds genuine value by disclosing the failure mode ('Can't add a login without a httpRealm or formActionOrigin'), the defaulting behavior, and that the password is written to the browser and never echoed back.

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 sentences, front-loaded with the purpose, then the constraint. The 'MEASURED:' framing is a slightly internal tic but each sentence carries real 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 four-parameter mutation with annotations and no output schema, the description covers the operation, the likely failure condition, and credential handling. It stops short of stating the return behavior (e.g., whether a login ID comes back) or duplicate-handling, which would make it 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 coverage is 100%, so baseline is 3; the description goes beyond it by explaining why formActionOrigin matters (the nsILoginInfo.init requirement and the httpRealm alternative) and by reinforcing that password is write-only, which the schema only states tersely.

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?

Specific verb plus resource: 'Save a username/password pair in the Firefox password manager.' An agent can tell this persists credentials rather than filling a page (browser_fill_login) or listing existing entries (browser_list_logins), 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?

The description never says when to choose this over browser_fill_login, browser_import_logins, or browser_import_logins_from_file, nor what prerequisites exist (e.g., profile unlocked, existing duplicate logins). Only an internal init constraint is mentioned, which is not usage 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, so the agent knows this mutates persistent state; the description adds nothing about what gets persisted, whether the engine becomes default, or how to remove it. The 'MEASURED:' provenance and internal API details describe implementation rather than observable behavior, which is of limited value at selection time.

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 core definition is correctly front-loaded in the first sentence, but the remaining text spends its budget on internal source-file paths and a taxonomy of unused SearchService methods that do not help an agent invoke this tool. That is padding relative to the two parameters involved.

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 tool with full schema coverage, no output schema, and annotations covering the mutation safety profile, the description covers what is needed to call it. The main remaining gap is the absence of any note on persistence, default-engine interaction, or reversibility for a destructive 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 both params are already documented in the schema, including the {searchTerms} requirement. The description restates that formInfo takes a name plus a URL template containing {searchTerms}, confirming no additional fields are needed, but adds no syntax or format detail beyond the schema — baseline 3.

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

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

The opening sentence gives a specific verb and resource ('Install a user-defined search engine'), which is unambiguous. It differentiates itself against internal SearchService add paths (addOpenSearchEngine, addSearchEngine, addEngineFromExtension) but never distinguishes itself from MCP siblings such as browser_search_engine or browser_get_search_engine, which is what an agent actually chooses 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?

It explains why this path is the simplest of four implementation options, which implies the use case (a plain name + URL-template engine), but gives no explicit when-to-use or when-not-to-use guidance against sibling tools that also touch search engines. Usage must be inferred.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, and the description goes beyond them by documenting the actual backing module, confirming writability, and warning that storage may be served from the Rust store depending on extensions.formautofill.addresses.storage.rust.* prefs. It still does not say what remove does to existing data or whether it is recoverable.

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 purpose is front-loaded in the first sentence, but the 'MEASURED:' investigative narration and the aside about 'an earlier note' are meta-commentary that costs the agent reading time without helping it select or invoke the tool.

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

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

For a destructive, multi-action mutation tool with no output schema, the description covers writability and a backend caveat but omits what list returns, whether remove is irreversible, and whether add fails without required fields. Just enough to call it, not enough to call it 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 description coverage is 100% and already explains guid (for remove), the action enum, and the fields object with an example, so baseline is 3. The description adds no parameter-level 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?

States a specific verb pair (read/write) and a precise resource (saved form-autofill addresses), and explicitly excludes passwords, which distinguishes it from browser_list_logins and browser_autofill_status. It does not name any sibling tool outright, so it stops short of full sibling routing.

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 first sentence implies the use case (viewing or editing saved autofill addresses) but never says when to choose this over browser_autofill_status or the login tools, nor what prerequisites exist. The Rust-store note is context, not selection 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?

Annotations already mark it read-only, and the description adds useful context about what is actually measured: the autofill module loading and exposing isAutofillEnabled. It also discloses the significant limitation that stored records are not writable through this build, though it does not describe the exact return shape.

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 core purpose is front-loaded in the first sentence, followed by measurement and scope caveats. It is reasonably concise, though the specific module paths are somewhat implementation-heavy for an agent-facing description.

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-only status tool, the description covers purpose, measurement basis, and scope limitations. It does not fully specify the returned status fields, which matters slightly more 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?

The tool takes zero parameters, so parameter semantics are minimal. The baseline for a parameterless tool is 4, and there is no parameter-related misinformation.

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: report the address/credit-card autofill state. It clarifies this is status-only and explicitly rules out editing saved autofill entries, which helps separate it from data-manipulation siblings, though it does not name an alternative tool.

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 a clear boundary: this tool only reports status, and editing saved autofill entries is out of scope because remote write is not exposed. It does not explicitly route the agent to a named sibling alternative, but the exclusion is clear.

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

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

Annotations declare destructiveHint=true, and the description correctly signals that 'create' writes a new file, so there is no contradiction. However it never explains what the destructive flag means in practice — whether an existing backup is overwritten, where files are written, or whether the operation is reversible — and the export-symbol listing is implementation detail rather than agent-facing 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?

The purpose is front-loaded in a single clear sentence, which is good structure. The remainder is a module path plus an export-symbol inventory ('getBackupFiles / getMostRecentBackup / saveBookmarksToJSONFile / create / getBookmarkCountForFile') that costs tokens without changing how an agent would call the tool.

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

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

With no output schema, the description is the only source for what 'list' returns, and it never says (file paths? names? timestamps?). For a simple one-parameter tool this is a modest but real gap; the note ruling out HTML export is the main value added.

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

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

There is a single parameter with 100% schema description coverage and an inline enum explanation ('list = show existing backups; create = write a new one'). The description merely restates those two actions, adding no format, naming, or scope 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?

The first sentence states a concrete verb+resource ('List the JSON bookmark backups in the profile and optionally create a new one'), which is unambiguous. The closing note that HTML import/export is unavailable implicitly separates this tool from the bookmarks_export/import siblings, though it never names them directly.

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 operational context: use list to inspect existing backups, create to write a new one, and it steers the agent away from an HTML path that does not exist in this build. It stops short of explicitly naming sibling tools (browser_bookmarks_export, browser_bookmarks_import) or stating when a backup should be taken.

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

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

Annotations already declare destructiveHint=true, but the description adds genuinely additive context beyond them: the blast radius of removal (children are deleted too), the well-known root GUIDs used to address toolbar/menu/unfiled/root, and the backing API surface. It does not cover permissions or what the list action returns, so not 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?

Three tight sentences, front-loaded with the resource and the sibling differentiation, then the safety caveat. The 'MEASURED:' prefix is terse internal jargon that costs a little readability but every sentence carries 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 4-parameter mutation tool with full schema coverage, no output schema, and annotations already flagging destructiveness, the description supplies the missing pieces: scope vs siblings, destruction of children, and root GUID addressing. Only the shape of the 'list' response is left unstated, which is a minor gap given there is no output 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 the baseline is 3; the description earns above that by explaining that root folders are addressed by fixed GUIDs (toolbar____, menu________, etc.), which materially changes how an agent supplies the `guid` and `parent` parameters, and by tying `action:"list"` to the child-count check.

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 the resource precisely ('bookmark FOLDERS') and explicitly distinguishes itself from the sibling bookmark tools that 'only handle individual bookmarks', which is the key disambiguation an agent needs. The verb is generic ('Manage') and the concrete actions (create/rename/remove/list) live in the title and the action enum rather than the description body, keeping it just 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?

Gives a concrete pre-condition for destructive use: 'Removing a folder removes its contents, so check the child count first with action:"list"' — that is real when-to-do-what guidance including a recommended tool sequence. It also implicitly scopes the tool against the individual-bookmark siblings, though it does not address the other folder-capable sibling (browser_bookmark_manage).

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is covered; the description adds useful build-level context (fetchTree unimplemented, so listing must use search). It still does not say what each action affects (e.g. that untag strips tags irreversibly or that update overwrites the existing title/url), which is the most valuable disclosure for a destructive multi-action 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?

Three sentences, front-loaded with the purpose and sibling boundary before implementation detail. The "MEASURED:" framing and API call signatures are slightly heavier than an agent needs, but nothing is padding.

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 an 8-parameter, action-dispatching mutation tool with no output schema and thin annotations, the description covers the underlying API semantics, the action-parameter relationships, and a notable capability limitation. What is missing is per-action guidance on required parameter combinations and what search returns.

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 each parameter already states which action it serves ("for move", "for update", "for tag/untag"), so the description's mapping of guid+parentGuid/index to move and title/url to edit largely restates the schema. Baseline 3 is appropriate given the schema carries the load.

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 the concrete operations (move via parentGuid/index, edit via title/url, search, tag/untag) and frames itself as "the management half of bookmarks," which is a specific verb+resource statement. It explicitly distinguishes itself from browser_add_bookmark, browser_remove_bookmark, and browser_bookmark_folder, so an agent can route correctly 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 states the boundary against the sibling bookmark tools (add/remove/folder) and adds a routing hint that listing should go through search({parentGuid}) because fetchTree is unavailable. It does not explicitly say when to prefer update versus move beyond the parameter mapping, but the context for use is clear.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true. The description adds implementation context such as the recursive walk and lack of usable exportToHTML, but never states whether an existing file is overwritten, what permissions are needed, or what the call returns.

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 purpose is front-loaded and the opening sentence is efficient. However, the "MEASURED" note and "TWO TRAPS" section consume substantial space on internal implementation details that do not help an agent select or invoke the tool, so the description is less concise than it could be.

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

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

Given the annotations and complete input schema, the description is mostly sufficient: it establishes what the tool writes and why. It still omits caller-facing details such as overwrite behavior and return value, keeping it below 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 coverage is 100%, so path and maxNodes are already documented in the input schema. The description mentions parentGuid and item.url only as internal implementation details, not as caller-facing parameter semantics, making baseline 3 appropriate.

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

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

The description names a specific action and target: "Write the bookmark tree to a Netscape Bookmark HTML file," and adds the output format. It does not explicitly contrast with bookmark-related siblings like browser_bookmark_backup or browser_bookmarks_import, so it falls short of full sibling differentiation.

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 use case: cross-browser bookmark movement via the same format Chrome, Edge and Safari export. It does not state exclusions or name alternative tools, so it lacks the explicit when-not and alternative routing 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?

Annotations already flag this as a non-read-only, destructive write, and the description adds real context beyond that: the build has no importFromHTML, so it parses with DOMParser and calls PlacesUtils.bookmarks.insert per item, and only one level of grouping is recreated. That grouping limitation is exactly the kind of behavioral trait an agent needs. It omits what happens on re-import of duplicates or on malformed files, which keeps it off 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?

Three sentences, front-loaded with the action and then the two behavioral facts that matter. The DOMParser/PlacesUtils implementation detail is borderline trivia but is framed as measured evidence of a capability gap, so it earns most of its space.

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

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

No output schema exists, and the description never says what the call returns, how partial failures are reported, or whether existing bookmarks in the target folder are preserved. For a destructive multi-item write tool, that leaves meaningful gaps even though the parsing and grouping behavior is well covered.

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 both parameters are documented in the schema. The description restates the destination concept ('under a chosen bookmark folder') and that the file is read, but adds no format, default, or validation 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 names a specific verb plus resource — read a Netscape Bookmark HTML file and recreate its folders and links under a chosen folder — which distinguishes it from single-item siblings like browser_add_bookmark and inverse operations like browser_bookmarks_export. It stops short of explicitly naming those siblings as alternatives, so it lands at a strong 4 rather than 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?

Usage is implied by the input format: you use this when you have a Netscape Bookmark HTML file to bring in. The description never states when to prefer it over browser_add_bookmark or browser_bookmark_backup, nor any prerequisites or exclusions, leaving the agent to infer the scenario.

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

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

Annotations declare readOnlyHint=true, yet the description describes mutation of browser state: adding overrides, clearing overrides, and an explicitly irreversible 'clear-all-overrides' operation. This directly contradicts the annotation. The incidental facts (removeCert absent in this build) are useful but cannot offset a false read-only claim.

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 purpose is front-loaded in the first clause. The second sentence is a dense 'MEASURED:' block of internal API names (addCert/getCerts/importCertsFromFile, rememberValidityOverride/clearValidityOverride) whose value to an agent choosing an action is marginal, though the note that removeCert is absent earns its place.

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

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

With no output schema, the description never indicates what 'list' or 'list-overrides' return, which matters for a read-heavy tool. It does cover the destructive-action precondition, but a mutation tool with a contradictory read-only annotation leaves an agent unable to form a correct safety model.

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 host/port/action/confirm are already documented, including the confirm requirement. The description restates the confirm:true precondition and names the nsI APIs behind each action but adds no syntax or default detail beyond the schema, so 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 concrete verb pair and resource: read the certificate database and manage per-host certificate exceptions, with the underlying APIs enumerated. It never differentiates from siblings like browser_list_cert_overrides or browser_relax_certificate_checks, so an agent cannot tell which one is the intended entry point from the description alone.

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 pick this tool over browser_list_cert_overrides, browser_list_certificates-style siblings, or browser_relax_certificate_checks. The only conditional ('clearing all overrides ... requires confirm:true') is a parameter rule, not usage guidance relative to alternatives.

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

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

Annotations already flag destructive/mutating behavior, and the description adds useful context: the operation targets the on-disk cache and is a different mechanism from ClearDataService. It stops short of stating irreversibility or whether in-memory cache or active tabs are affected.

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 sentences, front-loaded with the core action and scoping rules. Dense but every clause carries information; the parenthetical API names are mildly noisy but justify the sibling distinction.

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 only two optional params, no output schema, and annotations covering the safety profile, the description supplies nearly everything needed: defaults, per-scope behavior, and sibling routing. Missing only confirmation of what persists after the clear and how it relates to browser_clear_site_cache.

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 baseline is 3, but the description adds real semantics beyond the schema: it explains the domain-vs-origin distinction in prose and, critically, what omitting both parameters does (whole-cache clear). That default behavior is not obvious from the schema alone.

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 ('Clear the on-disk HTTP cache'), names the underlying API, and explicitly separates itself from browser_clear_data by describing the different service path. An agent can identify exactly what this does 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?

Gives clear conditional routing: use origin for a single site, domain for a base domain, no args for the whole cache, plus an explicit exclusion against browser_clear_data. The one gap is that browser_clear_site_cache, the semantically closest sibling in the list, is never mentioned or distinguished.

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

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

Annotations already declare destructiveHint=true, so the safety profile is covered; the description adds real value by specifying the exact data categories destroyed (cookies, storage, caches) and the deliberate single-site scoping. It stops short of stating irreversibility, whether open tabs need reloading, or container/context interaction.

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 sentences, front-loaded with the verb and the scope constraint, then the safety rationale. The design-rationale clause is slightly chatty but earns its place by deterring accidental global deletion.

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 destructive tool with annotations, fully documented params, and no output schema needs scope, destruction set, and safety framing — all present. Missing: whether the call is irreversible, and its effect on a currently loaded page versus persisted profile data.

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 adds a constraint absent from the schema: one of host or origin must be supplied. Note this conflicts with the schema's required: 0, leaving ambiguity about enforcement.

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?

Specific verb+resource ("Delete stored data") with an explicit scope qualifier ("ONE host or origin") and an enumeration of what is removed (cookies, storage, caches). It does not, however, distinguish itself from near-identical siblings such as browser_clear_site_cache or browser_delete_cookies, so the agent must infer the difference.

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 'clear everything' path here on purpose" is a useful when-not signal, but it never names the alternative (browser_clear_cache) or the narrower cookie-only sibling. Usage context is implied rather than routed.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds real behavior beyond that — the schemeless-site trap, the callback-object requirement that otherwise 'hangs forever,' and the meaning of resultFlags 0. Some of this (ClearDataService, new, the exact method signature) is developer-facing internals rather than agent-actionable behavior, which keeps it from 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?

The key point is front-loaded well and the 'two traps' are genuinely useful, but the middle chunk detailing ClearDataService, `new`, and the full deleteDataFromSite signature is implementation detail an agent calling this tool cannot act on. That material dilutes an otherwise tight description.

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 single-site clear with annotations carrying the safety profile and no output schema, the description covers scope, the critical schemeless input requirement, and success signaling (resultFlags 0). It omits details about the 'kinds' selector behavior and effects on currently loaded pages, but is otherwise sufficient to invoke 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 coverage is 100% and the 'site' schema entry already documents the schemeless format, so the description largely restates that trap for emphasis rather than adding new semantics. The 'kinds' parameter is not elaborated beyond the schema's 'default: all caches,' so it does not compensate further.

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

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

The opening sentence states a specific verb and resource ('Clear cached data') and explicitly scopes it to 'a SINGLE site instead of the whole cache,' which distinguishes it from the whole-cache sibling (browser_clear_cache). An agent can identify the operation and its scope 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?

The phrase 'instead of the whole cache' implies the alternative tool and the condition that selects this one (targeted, per-site clearing). It gives clear context but never names browser_clear_cache or browser_clear_data explicitly, so there is mild inference left to the agent.

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

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

readOnlyHint=false already marks this as a write-ish interaction, and the description adds genuine behavioral context the annotations do not: it dispatches a real trusted pointer sequence (move, down, up) at the element's centre, which matters for pages that distinguish trusted events. It omits failure behavior (no match, hidden element), auto-scroll, and waiting, keeping 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?

One sentence, front-loaded with the action and resource, with the mechanism qualifier immediately after. Nothing is padded and nothing is 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?

For a simple two-parameter interaction tool with an annotation and full schema coverage, the definition covers what the tool does and how it acts on the page. It does not cover what happens when the selector matches nothing or the element is obscured, which is the main remaining gap.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema. The description reinforces that the selector resolves to the first match only, but says nothing about the `context` tab-id parameter or selector syntax; 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 ("Click the first element matching a CSS selector") plus the mechanism ("real mouse action... at its centre"), which separates it from coordinate-based browser_mouse_action and synthetic clicks via browser_evaluate. It never names a sibling or says what it does not do (e.g. no hovering, no typing), 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?

Usage is only implied by the tool's obvious semantics; the description gives no when-to-use/when-not, no mention of alternatives such as browser_mouse_action for coordinate clicks or browser_hover for non-clicking pointer moves, and no prerequisites such as the element needing to be visible.

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?

Goes well beyond the single readOnlyHint=false annotation by disclosing the actual mechanism: there is no Firefox close-popup API, so the panel element is merely hidden. That is important context, since the popup may persist in the DOM rather than truly being destroyed, and it notes the tool reports what it found and closed.

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 its target, followed by the implementation caveat and the result behavior. No sentence is 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 zero-parameter, non-destructive cleanup tool with no output schema, the description covers purpose, mechanism, the API limitation, and a hint at the return value. Nothing an agent needs in order to call it correctly 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The description correctly avoids 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?

States a specific verb (close) and resource (the tool-panel popup opened by browser_open_extension_popup), and explicitly names the sibling it pairs with. An agent can distinguish this from browser_close_tab or browser_quit 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?

The pairing with browser_open_extension_popup makes the when-to-use condition clear: close what that tool opened. It does not state a when-not-to-use case or what happens if no popup is open, but the implied context is unambiguous.

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

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

The description goes far beyond the simple `readOnlyHint: false` annotation by detailing crucial operational behavior. It explicitly states that 'Pinned tabs are left alone' and that the action mimics the built-in menu, adding essential constraints that the API structure alone cannot convey.

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 definition is perfectly sized. The first sentence defines the core function and mechanism, and the second sentence adds critical constraints (pinned tabs) and use case, with 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?

Given the complexity of the operation (closing multiple tabs based on an exclusion list), the description is completely sufficient. It covers the mechanism, the constraints (pinned tabs), and the intended use case, leaving the agent with all necessary operational information.

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 100% schema coverage, the parameter semantics are well-covered by the input schema itself. The description clarifies that the 'context' is the ID to keep, which reinforces the schema but adds minimal semantic value beyond the structured definition. Baseline score 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 purpose is perfectly clear: to close tabs while preserving a specified tab. The use of the phrase 'Close all tabs in the window except the given one' is highly specific, and mentioning the 'close other tabs' context menu reinforces its precise function.

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?

While it doesn't explicitly contrast itself against every sibling, it provides a strong 'when' context: 'Use it to clean up after a series of agent tabs.' This practical guideline helps the agent determine the appropriate operational scenario for this complex close action.

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

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

With only readOnlyHint=false available, the description carries real weight: it discloses that only the tab closes, that the browser survives, that the reply reports remaining tab count, and that Firefox itself may exit when zero tabs remain. That last point is a genuinely useful non-obvious side effect; return-format detail is the only remaining 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?

Three tight sentences with zero filler; the scoping claim comes first, then target selection, then the reply/warning behavior. Every sentence adds a distinct fact.

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, yet the description describes what the reply contains (remaining tab count, warning at zero), which is exactly the missing piece. Precedence between the three optional parameters is the only thing an agent might still want spelled out.

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 baseline is 3, but the description adds precedence and defaulting semantics ('default to the active tab') and tells the agent where context ids come from. It stops short of elaborating conflict cases such as context supplied together with index.

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 ('Close one tab') plus the underlying API call (browsingContext.close). The clause 'this closes only that tab; the browser keeps running' immediately separates it from browser_quit, browser_close_window, and the bulk-close siblings (browser_close_other_tabs, browser_close_tabs_by_url).

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?

Explains exactly how to select the target: context id (sourced from browser_list_tabs), 0-based index in the active window, or default to the active tab. It does not explicitly name when to prefer a bulk-close sibling instead, but the single-tab scoping makes that inference direct.

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 only readOnlyHint=false available, the description adds meaningful behavioral context by explaining substring matching and noting that the implementation walks tabs and calls removeTab. It does not cover edge cases like pinned tabs or undo behavior, but it is substantially more informative than the annotation alone.

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 first sentence front-loads the core action, and the remaining sentences provide relevant matching and usage context. It is appropriately sized, though the internal gBrowser API detail is slightly heavier than necessary for tool selection.

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 destructive tool with no output schema, the description covers what it does, how matching works, and a primary use case. Minor gaps remain around pinned tabs, grouped tabs, and no-match behavior, but the essential information is 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 coverage is 100%, so the baseline is 3, but the description adds important meaning: the pattern is matched as a substring, not as an exact URI or necessarily as a regex. The 'example.com' example clarifies the matching behavior well, despite a mild tension with the schema's 'text or regex' wording.

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: closing all tabs whose URL contains the given text. It distinguishes itself by matching URL substrings rather than closing a single tab, though it does not explicitly name sibling tools like browser_close_tab or browser_close_other_tabs.

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 use case: cleaning up after a batch run without affecting unrelated tabs. It does not explicitly state when not to use it versus browser_close_tab or browser_close_other_tabs, but the context is strong enough.

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

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

Annotations only declare readOnlyHint=false; the description adds the non-obvious behavioral detail that trailing pinned tabs are preserved, matching the menu. It does not say whether closed tabs land in the recently-closed list or are otherwise recoverable, which for a bulk-close mutation would be valuable.

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 zero waste, the scope front-loaded and the exception second. Nothing is repeated and nothing is 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?

Covers scope, boundary default, and the pinned-tab exception with no output schema to explain. The one meaningful gap is recoverability of the closed tabs, which an agent deciding to call a bulk-close operation would want to know.

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

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

Schema coverage is 100% and the single optional `context` parameter already documents the left-boundary semantics and its default. The description's 'the given one' merely agrees with the schema rather than adding format or selection guidance, so 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 ('Close every tab to the right of the given one') and anchors it to a known UI affordance in the tab context menu. This cleanly separates it from siblings like browser_close_tab, browser_close_other_tabs, and browser_close_tabs_by_url without needing to open 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?

The parenthetical naming the context-menu equivalent implies the use case, and the boundary semantics are clear. However, it never explicitly contrasts itself with the nearest alternatives (browser_close_tab, browser_close_other_tabs, browser_close_tabs_by_url), leaving the routing decision 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?

readOnlyHint=false only marks this as a mutation; the description carries the real weight by spelling out the blast radius — every tab in the window dies, not just the current one — and that the default target is the active tab's window. It does not say whether closed windows can be reopened or whether prompting/unload handlers intervene.

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 core fact is front-loaded, but the middle clause is garbled — 'it acts on the active tab is NOT what happens here' reads as a leftover edit and forces the reader to parse twice. A tighter phrasing would have made the same warning in half the 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 one-optional-param destructive tool with no output schema and minimal annotations, the description covers target resolution, default behavior, and the sibling boundary. Only the irreversibility/undo story 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 single context parameter is already documented, including that any tab id in the window resolves to its top-level window. The description restates the same default but adds no format or id-source details beyond the schema, so this sits at the baseline.

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

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

States a specific verb and resource (close a whole window, all tabs) and grounds it in the underlying primitive (BiDi browsingContext.close on a top-level context). It explicitly separates this from browser_close_tab, so an agent can pick between them without opening 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?

Names the alternative browser_close_tab and the condition that selects it (single tab), plus a caution to 'check first' before invoking since the target is the whole window the tab belongs to. It stops short of covering other nearby destructive siblings like browser_quit or browser_close_other_tabs, so not a full routing map.

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?

Goes well beyond readOnlyHint=false, disclosing a non-obvious side effect (it also intercepts the response-started phase because Firefox clones the body there), the blocking behavior of premature reads, and a concrete failure string ("no such network data") with its cause. It also documents the lifecycle: who holds the response, who releases it, and how to clear interception.

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 core instruction (turn it on first) is front-loaded, and every sentence carries real operational content. One clause is garbled/duplicated ("releases the response and only then reads the body only after network.responseCompleted"), which slightly hurts scannability.

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

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

Covers activation, timing, reading, error modes, and teardown for a tool with no output schema, which is nearly everything needed. The notable gap is scope: it never says whether collection applies browser-wide, per-tab, or per-request-filter, and there is no tab/target parameter to infer it from.

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 maxSize is already documented there with its default of 1 MB, so a baseline 3 applies. The description says nothing about maxSize or what happens when a body exceeds the bound, adding no 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?

Names the specific action ("Turn on BiDi response-body collection") and cites the underlying primitive network.addDataCollector. It clearly separates itself from the sibling that reads the data (browser_get_response_body) and the sibling that tears down interception (browser_network_intercept stop).

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

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

Explicitly states the ordering precondition ("must be switched on BEFORE the request you care about happens") and explains why a completed request cannot be collected. It routes the agent to browser_get_response_body for reading and to browser_network_intercept stop for cleanup, so both the when and the when-not are covered.

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

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

Annotations only declare readOnlyHint=false, so the description does add real context: the tool spawns a standalone devtools:webconsole window, the same thing the menu item does, and it names a known failure mode. That is useful behavioral disclosure beyond the annotation. It still says nothing about what happens when closing a console that isn't open, whether toggle is idempotent, or what the tool returns.

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 purpose is front-loaded in the first sentence, which is good. But the following two sentences are an internal API post-mortem and a verbatim thrown-error string, which do not help an agent decide to call this tool or how to fill in action, and they push the definition from a one-liner into an essay.

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

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

The tool is simple: one required enum parameter, no output schema, minimal annotations. The description covers what the window is and where it appears, which is enough to call it. The remaining gap is behavioural edge cases (close when not open, toggle semantics), which is minor at this complexity.

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

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

Schema description coverage is 100% (the action enum with open/close/toggle), so the baseline is 3 and the description adds no meaning about the enum values beyond the title. The 'call ... with NO arguments' note refers to an internal manager method, not the tool, and risks being misread as licence to omit the required action parameter.

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

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

States a specific verb pair (open/close) and a specific resource (the Browser Console window, described as the Ctrl+Shift+J window that logs browser-wide messages). That distinguishes it from most siblings, but the nearest neighbour, browser_console_logs, is never named or contrasted, so an agent must infer the split between 'open the console window' and 'read console logs'.

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

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

There is no when-to-use guidance at all: no statement of when an agent should open vs. close vs. toggle, no prerequisites, and no mention of the sibling that returns log content. The only 'usage' content is about an internal manager API (openWindow() vs. openBrowserConsole(win)), which is implementation trivia rather than agent-facing selection 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?

Goes well beyond readOnlyHint=true: it discloses in-memory buffering, a 500-entry cap, connection-only scope, and the consequence that nothing before connect is visible. That last point is the kind of non-obvious constraint that would silently produce empty results otherwise.

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: what it reports, what each entry contains, then the constraints and sequencing advice. Front-loaded and every sentence carries distinct 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?

With no output schema, the description compensates by naming the entry fields (level, text, source) and the retention/scope limits. Nothing an agent needs to call it correctly, or to interpret an empty result, 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 description coverage is 100% and the single 'limit' param already documents 'newest first, default 20'. The description adds nothing about the limit or ordering, which is fine given the schema, but it also doesn't reinforce default-vs-max behavior. Baseline 3.

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

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

States a specific verb and resource ('Report console messages the page produced') and even names the underlying protocol event (BiDi log.entryAdded), so an agent knows exactly what it gets back. It doesn't explicitly contrast with the sibling browser_console, which is the one place an agent could confuse the two, 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?

Gives concrete operational sequencing – 'open the page and act first, then read' – which is exactly the guidance needed for a connection-scoped buffer. It's clear about context but never names an alternative tool or states when not to use it, so no 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?

Annotations only supply readOnlyHint=false; the description carries the behavioral load and does so usefully by disclosing that the operation creates persistent state, that the new context isolates cookies and storage, and that cleanup requires a separate call. It stops short of saying whether creation is idempotent or what happens on failure, but the key mutation semantics are covered.

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

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

Purpose and return value are front-loaded, but the phrase 'The id can be passed to browser_create_container style workflows' is self-referential and confusing inside browser_create_container's own description, and the trailing Firefox-account-tabs clarification is only loosely connected. One wasted/unclear clause in a short description costs it.

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 creation tool with no output schema, the description covers what the agent needs: what gets created, what the return value is (an id), what the id is good for, and how to undo it. A brief note on context lifetime or limits would make it fully complete.

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

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

The tool takes zero parameters, so there is no parameter semantics to add and the baseline applies. The description correctly implies no configuration is needed to create the context.

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 ('Create a new container / user context'), names the underlying BiDi primitive (browser.createUserContext), and notes the return value (its id). It also explicitly distinguishes the tool from browser_remove_container and from Firefox account tabs, so an agent can tell it apart from related 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?

Gives clear context: the returned id is what isolates cookies and storage and can be fed into follow-on workflows, and removal is routed to browser_remove_container. It doesn't mention browser_list_user_contexts or state when a container is preferable to, say, a fresh window/profile, so alternatives aren't fully enumerated.

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

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

Annotations declare destructiveHint=true, and the description earns credit beyond them by spelling out exactly what gets destroyed: with no filter it clears every cookie the session can see. That is the single most important behavioral fact for this tool and it is stated plainly.

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 action and its filter semantics, ending on the destructive default. No filler and no repetition of schema content.

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

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

For a two-optional-param mutation with no output schema and full annotation coverage, the description supplies the action, the filter model, and the destructive default. Nothing an agent needs to call it safely 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% and documents both optional params, so the baseline is 3. The description adds real meaning on top: the params are combinable filters and the zero-param case has a distinct, dangerous semantic (delete all) that the schema's empty required list alone would not convey.

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 cookies") plus the underlying BiDi call (storage.deleteCookies), and the filter scoping immediately separates it from browser_get_cookies, browser_set_cookie, and bulk browser_clear_data. An agent can identify the operation 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?

Gives explicit operational guidance: supply name and/or domain, and only omit both if you intend to wipe every visible cookie. The when-not condition is stated as a warning rather than an alternative-tool routing (e.g. vs browser_clear_site_cache), so it stops just 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?

Annotations only declare readOnlyHint=false, so the burden is mostly on the description, and it does convey that 'all' clobbers every toolbox rather than one. However it never says what is lost when a toolbox is closed (inspector state, unsaved console/element selections) or whether the call fails when no toolbox exists. The cited entry points add a note of implementation grounding but no behavioral consequence.

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 opening sentence is front-loaded and efficient. The second sentence spends roughly half the description quoting internal Firefox entry points, which is meta-commentary an agent cannot act on and crowds out more useful guidance such as prerequisites or the closed-state outcome.

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-optional-parameter tool with no output schema and only a single annotation, the description covers both call modes and the default-tab behavior. The remaining gap is what happens on success/failure and whether the tab's DevTools state is recoverable, which is a moderate rather than severe omission.

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 both `all` and `context` are already documented (including the active-tab default), and the description's phrase 'for a tab, or all of them' only restates them. The `{destroy}` token in the second sentence references an option that is not a parameter, which adds confusion rather than semantics. Baseline 3.

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

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

States a specific verb and resource: 'Close the DevTools toolbox for a tab, or all of them.' An agent can distinguish this from browser_devtools_open and browser_devtools_tools by the close/open contrast. It stops short of naming those siblings explicitly, so it lands at 4 rather than 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 'for a tab, or all of them' implies the two modes but never states when to use which, nor any prerequisite such as DevTools having been opened on that tab first. There is no mention of the complementary reopen path (browser_devtools_open) after closing, leaving the agent to infer the lifecycle.

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

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

Annotations only declare readOnlyHint=false, so the description carries most of the burden and does add real context: the toolbox may open in a separate window, which explains why its markup isn't in the page document. That prevents a costly wrong assumption, though it doesn't say how to verify the toolbox opened or how to shut it (the close sibling handles that).

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. The MEASURED note about gDevTools.showToolboxForTab is somewhat implementation-facing and less actionable for an agent, but the rest is tight and earns its space.

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

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

For a two-parameter tool with no output schema, the description covers the key behavioral surprise (separate window) and the source of valid ids. The absence of return-value detail is acceptable since there is no output schema to rely on, but a hint about confirming the panel opened 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?

Schema coverage is 100% with an enumerated tool id and described context parameter, so the schema already does the heavy lifting. The description's note that ids come from browser_devtools_tools is mildly useful but largely redundant since the enum is already listed.

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: open the Firefox DevTools toolbox on a tab and select one panel. It also names the sibling that supplies tool ids (browser_devtools_tools), so an agent can distinguish this from the list-tools and close-toolbox siblings 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?

It routes the agent to browser_devtools_tools for valid tool ids and explains the default tab behavior via the schema. It doesn't state when to prefer this over browser_devtools_tools or browser_devtools_close, but the context for use is clear.

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

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

readOnlyHint=true already establishes the safety profile, and the description usefully confirms that the output pairs panel names with ids. However, the second sentence is internal implementation trivia (loader path, module id, exported symbol) that discloses nothing an agent needs about the tool's runtime behavior, and there is no mention of return shape or failure modes.

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

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

The first sentence is well-structured and front-loaded with the actionable content. The trailing 'MEASURED:' note on loader internals is off-topic for a caller and adds length without helping selection or invocation.

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 has to say what comes back, and it does: the list of panel identifiers together with the id usable with browser_devtools_open. Only the exact return structure (field names, ordering) is left unspecified.

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 parameter semantics is trivially satisfied and the baseline of 4 applies. Nothing about arguments needs documenting beyond the empty schema.

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

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

Specific verb ('List') plus specific resource ('Developer Tools panels this Firefox exposes'), and it enumerates the panel names so the agent knows the output domain. It also distinguishes itself from siblings by naming browser_devtools_open as the consumer of the returned ids.

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 ties usage to a concrete next step: the returned ids are 'the id you can pass to browser_devtools_open', which tells the agent when to reach for this tool before opening a panel. It stops short of explicit when-not conditions or naming browser_devtools_close as an alternative.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds real context beyond that: the walk is bounded by depth/node budgets, the root is '#document' with numChildren, and the underlying inspector walker is disclosed, giving confidence about what the call actually does. It stops short of describing node payload fields or truncation behavior when budgets are hit.

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 action and the output shape, then the sibling contrast. The 'MEASURED: ... -> ... -> ...' call chain is somewhat implementation trivia that consumes space, but it is compact and does convey the mechanism.

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 the description conveys the essential return shape (outline rooted at #document with numChildren) and that it is budget-limited. It does not explain the node record fields or what happens on truncation, which is the main remaining gap for a tool with no output 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 context, maxDepth and maxNodes are already fully documented with defaults and ranges in the schema. The description only reinforces the notion of a 'bounded outline' without adding per-parameter semantics, so 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 ('Walk a real DOM tree through the DevTools inspector walker') and a specific output ('bounded outline'), and explicitly contrasts itself with sibling browser_page_source. An agent can distinguish this from browser_page_source or browser_a11y_tree 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?

Names the alternative browser_page_source and the condition that favors this tool ('far cheaper for large pages'). It does not address other plausible alternatives such as browser_evaluate or browser_a11y_tree, so it stops short of full exclusion guidance, but the context is clear.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, and the description is consistent with that by framing the tool as a write. It adds a real operational detail (parent directory must exist), but leaves key behaviors unexplained: whether an existing file at the target is overwritten, what the tool returns so the download can be tracked or later cancelled, and whether authentication or permissions are involved.

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 opening sentence and the path precondition both earn their place, but the middle sentence ('MEASURED: Downloads.createDownload exists on the module from resource://gre/modules/Downloads.sys.mjs ...') is internal implementation trivia that helps neither selection nor invocation and consumes roughly a third of the text.

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 should tell the agent what comes back (a download handle/id) so a subsequent manage, pause, or cancel call is possible; it does not. It also omits failure modes such as invalid URLs or existing targets, leaving a mutation tool only partially specified despite the sound path precondition.

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?

Both parameters are already fully documented in the schema at 100% coverage, so the baseline applies. The description does add one non-obvious constraint not in the schema — the parent directory must pre-exist — but offers no format details, size limits, or destination-conflict behavior beyond that.

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 ('Begin a download of a URL to a local file') and explicitly distinguishes itself from the sibling browser_download_manage by calling itself 'the write half that browser_download_manage does not cover.' An agent can separate it from browser_list_downloads, browser_list_download_events, and browser_set_download_dir 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?

Names the complementary alternative (browser_download_manage) and gives a concrete precondition: 'Pass an absolute target path; the parent directory must exist.' It stops short of stating the inverse condition (use browser_download_manage to list, pause, or cancel a download), so usage is strongly implied but not exhaustively framed.

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

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

The description provides deep technical context by citing the underlying source code module (`resource://gre/modules/Downloads.sys.mjs`) and specific methods like `remove(item)` and `removeFinished(filter)`. This technical insight helps an agent understand the constraints of the operation, even though annotations already flag it as destructive.

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

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

The description is efficient and highly focused on its functional scope. While the technical meta-commentary ('MEASURED', 'NOTE') adds bulk, it is all necessary to prevent confusion with other tools and defines the boundaries accurately.

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

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

Given the annotations (destructive/non-read-only) and high schema coverage, the description is maximally complete. It addresses the 'why' and 'how it fits' for this tool, providing essential context for an agent deciding between several related download management tools.

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?

Since schema description coverage is 100%, the schema already provides complete semantic information for the parameters (action and index). The description does not offer any additional meaningful context beyond the general usage defined in the title.

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

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

The tool title and description clearly define its purpose as managing (removing, clearing, or opening) download entries. It excels by explicitly stating that it covers the 'management half' of downloads, a concept that immediately differentiates it from listing or setting states.

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 exceptionally clear. The description provides explicit boundaries by referencing and contrasting itself with specific sibling tools: `browser_list_downloads` and `browser_set_download_state`. This tells the agent exactly when *not* to use it.

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

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

Annotations only declare readOnlyHint=false, so the description does the heavy lifting by disclosing a significant behavioral limitation: this tool does not synthesize a drop event for HTML5 drag-and-drop, and the upstream bug is identified. It also explains step-count behavior for drag-tracking pages. It does not address permissions or failure behavior, which keeps 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?

Front-loaded with the action, then the step-tuning advice, then the critical HTML5 limitation and alternative. The bug citation is verbose (includes filing date and status) but is directly relevant to the routing decision, so every sentence earns its place, albeit with some excess detail.

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

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

For an eight-parameter mutation tool with no output schema, the description covers the mechanism, the tuning knob, the compatibility limitation, and the alternative. It does not explain selector-versus-coordinate precedence or defaults (context tab, steps), but those are fully covered by the schema at 100% coverage.

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 adds real semantic value for `steps` by explaining why step count matters and when to raise it, beyond the schema's 'Intermediate move steps (default 12)'. Source/target selector versus coordinate duality is left to 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 and mechanism: 'Perform a real mouse drag: press on the source, move in steps, release on the target.' It also explicitly distinguishes itself from the sibling browser_drag_html5, so an agent can choose between the two 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?

Gives explicit when-to-use guidance (raising `steps` for pages that track dragging) and an explicit when-not-to-use rule: HTML5 drag-and-drop will not produce a drop event, so use browser_drag_html5 instead. The alternative and the condition that selects it are both named.

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?

Goes well beyond readOnlyHint=false: it discloses the exact events synthesized, that the drop is simulated in page script rather than a real drag, the underlying BiDi/Firefox limitation and upstream bug, and the resulting failure modes. This is exactly the side-effect context an agent needs before attempting a drag.

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?

Front-loads the action, then the rationale and caveats in clearly labeled clauses; dense but every part is relevant. Mild redundancy in restating the upstream-bug rationale at the end costs it a point.

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, but the description makes clear what the tool does and does not achieve, and what kinds of pages it will fail on — everything an agent needs to decide whether to call it or fall back to browser_drag.

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 fromSelector, toSelector, data and mimeType (including defaults) are already documented in the schema. The description adds no per-parameter meaning, 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 and resource ('Perform an HTML5 drag-and-drop by dispatching the DOM events ... with a real DataTransfer') and explicitly contrasts it with the sibling pointer-based browser_drag, so an agent can pick between them 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?

Gives explicit when-to-use ('works on pages that listen for the standard drag events') and when-not ('pages that check event.isTrusted, or that require genuine OS drag semantics, will still refuse'), plus the named alternative browser_drag and why it fails.

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?

readOnlyHint=false is consistent with a tool that creates a tab, and the description adds real context the annotation cannot: the clone inherits history and state and is inserted adjacent to the source tab. It also warns about leaving stray tabs open. It stops short of saying whether the source tab or the clone becomes active, which is the main behavioral unknown for an agent.

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 the tool does, with the key behavioral property (history/state retained) before the operational advice. The gBrowser.duplicateTab reference earns its place by disambiguating against a plain new tab.

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 the description never says what the call returns — most importantly whether the new tab's context id is handed back so the agent can act in the clone, which its own advice ('continue in the new copy') depends on. It also leaves focus/activation behavior 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%, so both parameters (context, background) are already documented in structured form; baseline 3 applies. The description implies default targeting ('the active tab') and background opening only indirectly, adding little 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 and resource ('Duplicate a tab') plus the defining property that separates it from browser_new_tab: it keeps history and state. The parenthetical naming gBrowser.duplicateTab anchors the exact semantics, and 'opens next to the original' pins the placement behavior.

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 use case ('cheapest way to keep where I was while the agent continues in the new copy') and a follow-up instruction to close the extra tab when done. It does not explicitly name browser_new_tab as the alternative for a fresh tab, so the exclusion 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?

readOnlyHint=true is consistent with a pure measurement operation, so the description correctly adds value elsewhere: it discloses the exact measurement method (mozInnerScreenX/Y + getBoundingClientRect centre) and warns against a specific failure mode (double-applying devicePixelRatio). It stops short of describing the return shape, which matters since there is no output schema.

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

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

Two sentences, purpose first, rationale second — well front-loaded with no filler. The MEASURED clause is longer than typical but earns its length by preventing a concrete off-target-cursor bug.

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-param read-only geometry helper this covers the why and the how thoroughly. The remaining gap is the return value's shape (coordinate object vs. pair of numbers), which the description gestures at with 'pixel centre' but never specifies, and there is no output schema to fall back on.

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 selector, context, offsetX and offsetY. The description only reinforces the 'centre' concept and says nothing about how offsets shift the target or how the tab context is resolved, so 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: 'Return the on-screen pixel centre of an element', plus the consumer ('handing to a native input driver'). The clause explaining that this exists for features that ignore synthesised DOM/WebDriver events implicitly separates it from browser_click / browser_mouse_action, which are the obvious siblings an agent might otherwise reach for.

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 concrete trigger condition: use this when a feature reacts only to genuine OS-level input, naming the DevTools eyedropper and HTML5 drag-and-drop as cases where DOM events fail. It never explicitly says 'use browser_click for ordinary clicks', so the exclusion is inferential rather than stated, but the context is clear enough to route correctly.

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?

Goes beyond the readOnlyHint=false annotation by explaining the mutation risk in plain terms ('it can change the page, so treat it as a write') and by disclosing that promises are awaited and the result is returned as JSON. Missing details like execution world, CSP behavior, or whether navigation can occur, but it adds genuine context on top of the annotation.

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 verb and return value, then mutation risk. Nothing redundant and 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?

No output schema exists, and the description covers the critical unknowns – return shape (JSON) and async handling (promises awaited) – plus the write-risk caveat. A note on execution context or failure modes would make it complete for a high-power arbitrary-code 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 both 'expression' and 'context' (default active tab) are already documented in the schema. The description adds no parameter-level meaning, so 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 ('Run an expression') and resource ('in the page') plus the return contract (its value, JSON). It's clearly distinguishable from siblings like browser_page_source or browser_dom_tree, though it never explicitly names an alternative to disambiguate against browser_console or browser_run_in_extension.

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?

Implied usage only – an agent infers this is the escape hatch for arbitrary JS when no dedicated tool exists. There is no explicit when-to-use statement and no named sibling as an alternative, which matters in a 150-tool namespace with browser_console and browser_run_in_extension nearby.

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

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

Annotations already declare readOnlyHint=true, so safety is covered; the description adds real behavioral value by stating the data is read from the live manifest and warning that AddonManager.optionsURL is null for MV3 extensions using options_ui. It does not cover failure behavior for an unknown/invalid id, 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 the outcome and followed by the implementation caveat. Every clause carries information; nothing is redundant with the title or 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?

With no output schema, the description usefully enumerates the three reported fields, and the manifest-source note explains where values come from. It stops short of describing return shape (e.g., nulls when no popup/sidebar exists) or error behavior, which would fully close the gap.

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

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

Schema coverage is 100% and the single parameter is documented ('Extension id'), so the schema does the work. The description adds no extra meaning about the id format (GUID vs slug) or how to obtain it, which is the baseline expectation when coverage is high.

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 ('Report what UI entry points an extension actually exposes') and enumerates exactly what is returned: options page URL, browser action popup, sidebar panel. This clearly distinguishes it from siblings like browser_open_extension_options (which opens rather than reports) and browser_list_sidebars (which lists sidebars globally, not per-extension).

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

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

The description implies a discovery/inspection use case and hints at why you'd want it (MV3 options_ui cases), but never says when to use it versus browser_open_extension_options, browser_list_addons, or browser_extension_permissions. No explicit exclusions or alternative routing 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 readOnlyHint already declared, the description adds strong context beyond annotations: it identifies the readable permission and origin string arrays, explains that the surface is available without opening about:addons, and clarifies that granting/revoking is extension-owned UI.

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

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

The description is short, front-loaded with the core action, and each sentence adds useful information: purpose, readable output shape, and the read-only limitation. There is no wasted framing.

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 read-only tool with full schema coverage and no output schema, the description is complete enough: it explains what is returned, what is not done, and why the read is possible. No important agent-facing gap is apparent.

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 id parameter is already documented in the schema. The description does not add parameter-specific meaning beyond that, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: reporting user-granted permissions and origin patterns of installed extensions. It also distinguishes the read-only permission surface from granting/revoking permissions, so the agent can tell it apart from mutation-oriented permission tools.

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

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

It clearly explains the context: use this to inspect granted permissions and origins, and it explicitly notes that this tool does not grant or revoke permissions. It does not name specific alternative sibling tools, so it falls short of full when-to-use/when-not/alternatives guidance.

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

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

With only readOnlyHint=false available, the description earns credit by disclosing the mechanism: a background tab is opened on an extension page, the call runs in that page context, and the tab is closed. It also flags a measured reachability limitation. It stops short of saying what mutating actions destroy or what read returns.

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 sentences: the first defines the resource and scope, the second explains the mechanism and its limitation. No filler, and the identifying information is front-loaded.

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

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

For a four-parameter tool with no output schema, the description covers the mechanism, the prerequisite, and the failure mode well. The main remaining gap is what a read returns (shape of the key/value result), which would help an agent plan the follow-up 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?

Schema coverage is 100%, so id, keys, data, and the action enum are already documented in the schema. The description adds context for the storage namespace but no parameter-level meaning (e.g., which actions require data or keys, or key semantics). 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 pair (read/write) and resource (extension private key/value storage, browser.storage.local) with the added clarification that it holds settings and lists. It is distinguishable from siblings like browser_extension_details or browser_run_in_extension, though it never names those alternatives 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 implied by the resource description, and a hard constraint is given (extensions without an options page cannot be reached). However, there is no explicit when-to-use versus browser_run_in_extension or browser_extension_details, and no guidance on which action to pick for a given goal.

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 only readOnlyHint=false supplied, the description carries most of the burden and does it well: it discloses that the call returns immediately, that the colour arrives later as an event, that a human click on the page is required, and that the picker session is cached on the chrome window so 'result'/'cancel' reach the same instance. It does not say what 'result' returns before any click, or what happens if 'start' is called twice.

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 actionable content is buried under internal implementation trivia (CommandsFactory.forTab, targetCommand.startListening, getFront("inspector"), spec file paths, bug 1701004) that an agent can never act on. Roughly half the text is Firefox-internals archaeology rather than decision-relevant guidance, and the 'MEASURED, and this is the whole trick' framing is noise.

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 the description does cover the return value indirectly ('reports the colour', carried as a string). For a two-parameter tool with one enum this is close to complete; the missing pieces are timeout/error behaviour rather than core capability.

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 both parameters are already documented and the enum description duplicates the schema. The description adds timing semantics to 'result' ('reports the colour once the user has clicked'), which is worth something, but adds nothing at all about the 'context' tab parameter. 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?

Opens with a specific verb+resource ('Drive the DevTools eyedropper / colour picker on a tab') and the three-action model is spelled out. It never differentiates itself from the obvious sibling browser_pick_color_at, so an agent cannot tell the two apart from the description alone.

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 start/result/cancel lifecycle is explained well, including why polling is required ('picking requires a real pointer press'). However, there is no statement of when to choose this interactive picker versus browser_pick_color_at or how to recover if the user never clicks (timeout/abandon), which is exactly the failure mode of a poll-based tool.

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

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

Annotations only carry readOnlyHint=false, so the description adds real value: it discloses that input is real keystroke synthesis rather than value assignment (matters for JS-validated forms) and explains why the Firefox password manager is not used, with observed evidence. It does not cover failure modes (field not found, selector mismatch) or whether credentials appear in logs.

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?

Front-loads the action and the keystroke distinction in one sentence, with the submit behavior appended. The final sentence about MEASURED Firefox autofill is longer than needed for invocation decisions, but it does preempt a plausible wrong approach.

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 mutation tool with full schema coverage and no output schema, the description covers what the tool does, how it types, and what it deliberately does not do. Only error/verification behavior (what happens when selectors don't match, how success is observable) is left unaddressed.

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 defaults for submit, context and the CSS selector fallbacks are already documented. The description only echoes the optional-submit behavior ('then optionally submit') and adds nothing about selector resolution 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?

Specific verb+resource ('Type a username and password into a form') with the scope narrowed further by 'real keystroke input (not a scripted value assignment), then optionally submit'. It also positions itself against browser_type and the password-manager siblings (browser_list_logins / autofill) via the 'you give me credentials, I fill them' framing.

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?

Clear usage context: it is for the case where the agent already holds credentials and should type them, and it explicitly rules out the native-autofill path. It does not name generic siblings like browser_type or browser_find_login_form as alternatives, so the routing 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds real value by disclosing the shape of what is inspected (form id, action, field name/type/autocomplete), which compensates for the absence of an output schema.

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

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

Two sentences, zero waste, with the return contents front-loaded and the usage rule following. 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?

For a read-only inspection tool with no output schema, the description supplies the essential return structure and the workflow context. Minor gaps remain — no mention of behavior when no form exists or whether it inspects iframes/shadow DOM — but the agent has enough to call it correctly.

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

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

The single 'context' parameter is fully documented in the schema (100% coverage), so the schema does the heavy lifting. The description says nothing about tab targeting or what happens if the context is omitted, so it adds no value over the structured field.

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

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

The description opens with a specific verb and resource ('Inspect the page for login/registration forms') and enumerates exactly what is returned: form id, action, and input fields with name/type/autocomplete. It is clearly distinct from data-oriented siblings like browser_list_logins, though it never names an alternative 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?

'Use this before filling a form so the field names are known instead of guessed' gives a concrete when-to-use condition and implicitly points toward the fill step. It stops short of naming the sibling tool (browser_fill_login) or stating when not to use it.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description doesn't need to restate that. It adds real value beyond the annotation by naming the API used and explicitly bounding what is measured (network cache only, not IndexedDB/Service Worker), which prevents misinterpreting the returned number.

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 action and scope come first, the caveat second. Nothing is repeated from the title or annotations and every clause carries useful 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-param read-only tool with no output schema, the description is essentially complete: it tells the agent what is measured and what is excluded. It stops short of saying what the return value looks like (number, units), which is a minor gap given there is no output schema to cover it.

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

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

The input schema is empty and has no parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a zero-parameter tool.

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

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

States a specific verb and resource — report the size of the on-disk HTTP cache — and cites the underlying API (Services.cache2.asyncGetDiskConsumption). It explicitly distinguishes this measurement from IndexedDB, Service Worker caches and storage, which an agent could reasonably confuse it with.

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 scope note makes clear when this tool is the right one: for network-cache disk consumption rather than broader storage. It doesn't explicitly point to siblings such as browser_clear_cache or browser_memory_usage, but the exclusion language covers the main ambiguity.

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

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

Annotations already declare readOnlyHint=true, so safety of the operation is covered; the description adds genuinely new context by naming the BiDi storage.getCookies call, noting values are returned as stored, and warning they should be treated as secrets. It stops short of describing result size or pagination 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?

Three short sentences, front-loaded with the action, then scoping, then the security caveat. Nothing is wasted and each 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?

For a zero-required-parameter read tool with full schema coverage and annotations, this is nearly complete: it explains what is listed, how to narrow, and how to handle the returned values. The only omission is any hint about result volume or handling of large cookie sets.

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 both parameters are already documented in the schema; the description's 'filter by name and/or domain' adds meaningful framing (they compose as optional narrowing filters) but no syntax or matching rules beyond that. 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 ('List cookies visible to the browser') and grounds it in the underlying BiDi call. The 'List' verb distinguishes it from siblings like browser_set_cookie and browser_delete_cookies, though it never names 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?

The description covers scoping ('Filter by name and/or domain to narrow it down') but gives no guidance on when to reach for this tool versus alternatives such as browser_import_cookies or browser_search_prefs, and no prerequisites or constraints are mentioned.

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

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

Annotations already declare readOnlyHint=true, and the description is consistent with that ('which favicon URL it has stored'). It adds real value beyond the annotations by defining the empty-result case as 'no icon has been recorded for that page yet' and clarifying that no image is downloaded — exactly the kind of context annotations can't carry.

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, each doing distinct work: what it does, what it returns, and how to interpret an empty result. The return-value constraint is front-loaded rather than 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 one required param, no output schema, and readOnlyHint already covering safety, the description fills the remaining gaps an agent needs: return shape ('the URL only'), the non-download caveat, and empty-result semantics.

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

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

Schema coverage is 100% and the single parameter is documented as 'Page URL to look up'. The description implies the lookup is per-page but adds no format guidance (absolute vs relative, internal URLs, etc.) beyond the schema — 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 ('Ask Places which favicon URL it has stored for a page') and immediately bounds it ('Returns the URL only — it does not download the image'), so an agent knows exactly what it gets. No sibling tool covers favicons, so differentiation is unambiguous.

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

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

The description makes the use case clear (look up the stored favicon URL for a page) and draws the key boundary against a plausible alternative behavior — fetching the icon bytes — which it explicitly disclaims. It stops short of naming a when-not-to-use condition, but no such alternative sibling exists.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds meaningful behavioral context beyond that: this command exists only in Marionette, not BiDi, and requires the browser to be launched with --marionette, including the port source and default. It does not state the exact return format, keeping it from 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 tight sentences: the first states what is read, the second gives the essential Marionette prerequisite. It is front-loaded and 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?

This is a zero-parameter read-only tool with no output schema, so the description does not need to explain parameters or return structure. It covers the purpose and the key environmental prerequisite, which is sufficient for an agent to invoke it correctly.

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

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

There are zero parameters, so the baseline is 4. The schema is empty and fully described; no parameter semantics are needed or expected.

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: read whether the browser sends the Global Privacy Control signal. It names the concrete header (Sec-GPC) and clearly distinguishes this getter from the sibling browser_set_gpc without needing to reference the 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 purpose makes clear this is a read-only check, and the NOTE gives an important usage condition: the browser must have been started with --marionette. It does not explicitly route agents to browser_set_gpc for mutation or mention when not to use it, so it falls 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?

Annotations only declare readOnlyHint=true, and the description goes well beyond that: it discloses that the return value is a clear-text secret, that both parameters are mandatory, and it gives handling constraints (no chat output, logs, screenshots). This is exactly the kind of context annotations cannot convey for a sensitive 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?

The security warning is front-loaded in the first clause, followed by rationale, then handling rules and prerequisites. Every sentence earns its place and nothing is 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?

Two required parameters, a read-only annotation, and no output schema — the description fills the gaps that matter by characterizing the return value (clear text secret) and the caller's obligations. Nothing needed to call it correctly 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?

Both parameters are documented at 100% schema coverage, so the schema already does the heavy lifting. The description reinforces that both origin and username are required for lookup, but adds no format, matching, or disambiguation guidance beyond that.

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 a saved password in clear text — and explicitly contrasts itself with listing operations, which is the nearest sibling behavior (browser_list_logins). An agent can tell immediately that this is the deliberate single-credential read, not an enumerator.

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 framing 'always a deliberate act, never a side effect of listing' tells the agent when to invoke it and implicitly routes enumeration to the list tool. It stops short of naming browser_list_logins or stating exclusions explicitly, but the usage context is unambiguous.

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

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

The readOnlyHint annotation already establishes the safety profile. The description adds useful context by noting the privileged context and that the result includes type and value, though it omits error or not-found 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?

It uses two short, front-loaded sentences with no filler. Both sentences carry operational 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 one-parameter read tool with no output schema, the description gives the essential context: privileged read by name and a basic return shape of type and value. It could say more about missing preferences or exact return structure, 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% and the only parameter is already documented with an example. The description's 'by name' adds no syntax or format detail beyond the schema, 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 states a specific verb and resource: read a preference by name. It does not explicitly distinguish this getter from the sibling browser_search_prefs, but the by-name scope is clear enough for selection.

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 'by name' implies when to use this tool, but there is no explicit guidance about when to use it instead of browser_search_prefs or other preference tools. Usage is inferable 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered; the description adds real behavioral context beyond that by enumerating the returned fields and warning that a proxy change may need a restart to affect existing connections. That restart caveat is non-obvious and directly actionable, though it does not discuss failure modes or unset values.

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 read, then the mode legend and the restart caveat. Every clause carries information; nothing is repeated from the title or 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?

No output schema exists, yet the description enumerates the returned fields and their value encoding, plus the one operational caveat (restart). For a zero-argument read tool this is as complete as an agent needs.

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?

Zero parameters, so the baseline is 4. The description goes further by decoding the returned mode field (0 none, 1 manual, 2 PAC, 4 auto-detect, 5 use system settings), which an agent would otherwise have to guess since there is no output 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?

Specific verb (read) plus resource (proxy settings) with the exact preference namespace (network.proxy.*) and the fields returned. It is unambiguously the read counterpart to browser_set_proxy and cannot be confused with any other 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?

Usage is only implied: the tool reads the current config, so an agent infers it should call this before/instead of mutating. It never names browser_set_proxy as the alternative for changes, nor states any precondition, leaving the read-vs-write routing 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered; the description adds real context beyond that: the ordering dependency on collection, the return shape (base64 plus decoded preview), and the meaning of the 'no such network data' error. It stops short of covering limits such as large/truncated bodies or how long stored bodies survive.

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 return shape, then the ordering constraint, then the error diagnosis. Nothing is redundant with the title or the 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?

No output schema exists, and the description compensates by stating exactly what comes back (raw base64 plus decoded preview) and how to interpret the main error. Minor gaps remain around body size/truncation and storage lifetime, which an agent might need for large or binary responses.

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?

Only one parameter and schema description coverage is 100%, so the schema already documents requestId and its origin. The description reinforces the id source and adds the temporal constraint (id must be from a request that occurred after collection started), which is marginal added value over 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?

Uses a specific verb and resource ('Read the stored body of one request') and even names the underlying protocol call (network.getData, dataType response). It is clearly distinguished from the sibling that stores bodies (browser_collect_response_body) and the sibling that supplies ids (browser_network_requests).

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

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

States the precondition explicitly ('The request must have happened AFTER browser_collect_response_body ran') and routes id lookup to browser_network_requests. It also names the failure mode and what to check, which effectively covers when-not-to-use / what to fix.

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

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

Annotations already declare readOnlyHint=true, and the description corroborates that with the reason (the SearchService ES module is unreachable, every resource:// path fails), which is genuinely additive context an agent cannot get elsewhere. It also discloses the underlying data sources, though it does not describe the return shape, ordering, or what happens if search.json.mozlz4 is missing or unreadable.

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 followed by the read-only caveat; the pref key and file name are concrete rather than padded. It is slightly dense but no sentence is 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 and no parameters, the description does the necessary work by naming the two returned pieces of information and explaining the read-only constraint. Only the failure behavior for a missing or unparseable search settings file is left unaddressed.

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 schema carries no semantics burden and the baseline applies. Nothing in the description needs to explain inputs, and it correctly does not invent any.

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 (report) and specific resources (the default search engine pref and the engine list from search.json.mozlz4), so its function is unambiguous. It stops short of distinguishing itself from the nearby siblings browser_search_engine, browser_search_prefs, or browser_add_search_engine, which a reader must resolve by inference.

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 context is only implied: the LIMITATION sentence tells the agent that changing the default engine is out of scope, which hints that a different route is needed for mutation. It never explicitly says 'use browser_search_engine (or browser_set_pref) to change it' or otherwise routes the agent to an alternative, and there are no stated preconditions.

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?

readOnlyHint=true already declares the safety profile, and the description adds useful depth by naming the exact data source (osPid), implying one entry per tab. However, with no output schema it does not say what the response shape is, whether all windows or only the current one are covered, or how discarded/unloaded tabs appear.

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 core purpose is front-loaded in the first clause, followed by the implementation detail and then the use case. Three sentences, all short. The 'that name does not exist in Tabbrowser.sys.mjs' sentence is defensive filler for an agent, though it does prevent a bad API assumption.

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-only introspection tool with no output schema, the description covers what it returns conceptually and why it matters. The remaining gap is scope (all windows vs. current window) and the exact return structure, which an agent would need before consuming the result.

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 input schema is an empty object, so there is nothing for the description to disambiguate. Baseline 4 applies; nothing is misrepresented.

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: report the OS process id behind each tab, with the exact underlying property (browsingContext.currentWindowGlobal.osPid). It is clearly distinct from siblings like browser_list_tabs (tab enumeration) and browser_memory_usage (aggregate memory), so an agent can pick 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?

Gives concrete motivation: see how many content processes Firefox spun up, or whether two tabs share one. That is a clear usage context, but there are no explicit exclusions or named alternative tools (e.g. use browser_memory_usage for totals). The 'MEASURED: no gBrowser.getTabPids' note is anti-hallucination guidance rather than selection 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?

readOnlyHint already declares the safety profile, so the bar is lower. The description nonetheless adds real context: the data is sourced from browser.uiCustomization.state and the returned widget ids are exactly the format browser_set_toolbar_widget accepts, which prevents an id-mismatch failure during a restore.

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 tight sentences: scope first, source and id semantics second, workflow third. Nothing is repeated and nothing is padding.

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-param read tool with annotations and no output schema, this covers scope, source, id compatibility and workflow. It stops just short of saying anything about the return shape (per-area arrays of ids), which would have made it fully self-sufficient.

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?

Only one optional parameter and schema description coverage is 100%, so the schema already documents 'area' with an example and the default of every area. The description's mention of areas matches but does not extend the schema, 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 — 'List which widgets sit in each toolbar area' — and names the underlying source (browser.uiCustomization.state) plus concrete area examples (nav-bar, TabsToolbar, PersonalToolbar). It is clearly the read counterpart to browser_set_toolbar_widget, so an agent can separate it from siblings 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?

Explicit sequencing guidance: 'Read this before changing the layout, and use it to put things back afterwards.' This tells the agent both the pre-condition and the restore workflow, and implicitly points at the mutation sibling that motivated it.

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

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

readOnlyHint=true is consistent with the description's read-only framing, so no contradiction. Beyond the annotation it discloses the concrete return payload (state enum, position, outer bounds), which is real added value. It omits which window is targeted — presumably the active one given zero parameters — and whether prompts/permissions are involved.

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, no filler. The returned data is front-loaded and the sibling routing follows immediately after.

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 must carry return-value semantics, and it does name all three returned values and the state enum. A small gap remains around window scoping (which window is measured) and whether coordinates are screen- or viewport-relative.

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 clarify, though it leaves implicit that the call always operates on the current/active window.

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?

Specific verb (report) plus the exact fields returned: window state with its enum values, screen position, and outer size. It also names the three writer siblings it complements, so an agent can distinguish it from browser_set_window_state / _position / _size 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?

The phrase 'readable counterpart of browser_set_window_state / browser_set_window_position / browser_set_window_size' effectively tells the agent to pick this for inspection and those for mutation. It does not, however, address when to prefer it over adjacent readers such as browser_list_windows or browser_screen_info.

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

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

The annotation only says readOnlyHint=false; the description goes beyond that by identifying the native Firefox tab-group mechanism and, importantly, disclosing that the result is a real tab-strip group a human can collapse or reopen later — a persistent, user-visible side effect. It omits edge behavior such as what happens to tabs already in another group and what the call returns.

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 its resource, with the implementation reference and the UI consequence following. No filler, though the parenthetical API name is marginally more useful to implementers than to an agent choosing the tool.

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

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

For a mutation tool with only readOnlyHint=false, no output schema, and no destructive hint, the description covers intent and persistence well but leaves gaps: whether grouping removes tabs from prior groups, whether the created group's identity is returned (relevant since browser_remove_tab_group exists), and any failure conditions.

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

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

Schema coverage is 100% and each of the three parameters is documented with descriptions plus an enum for color, so the schema carries the load. The description's "contexts required, label and color optional" restates the schema's required array rather than adding new semantics, 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 and resource: "Create a tab group from the given tabs," naming the underlying implementation (gBrowser.addTabGroup). An agent can tell this makes a new group rather than mutating an existing one, though it never explicitly contrasts with the nearby browser_move_tab_to_group or browser_list_tab_groups 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?

"Give the tab context ids; label and color are optional" implies the calling convention, but there is no explicit when-to-use guidance, no statement of prerequisites (must the tabs be in the same window? must they be ungrouped?), and no named alternative for putting tabs into an existing group.

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

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

Annotations only give readOnlyHint=false; the description adds the real behavioral payload — that the page remains blocked until this is called, that accept maps to OK/Cancel, and that a "no such alert" error is a normal, non-failure outcome. That last point meaningfully prevents the agent from treating a benign error as a fault. It doesn't say what the tool returns or whether dismissing a confirm discards unsaved state.

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

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

A single tight block: purpose first, then parameter meaning, then the failure/blocking consequence. Every clause carries information and 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?

For a three-parameter dialog tool with no output schema, the description covers purpose, both meaningful parameter behaviors, and the blocking/error semantics. Only the return value and any post-dismiss state effects are left implicit, which is a minor gap here.

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 accept, context and userText are already documented in the schema. The description restates accept and userText semantics without adding new detail and never mentions the context parameter. Baseline 3 applies when the schema carries the parameter burden.

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 (answer/accept/dismiss) and a specific resource (a page prompt: alert/confirm/prompt), and even names the underlying BiDi command. It is clearly distinguishable from the other browser tools, though it never names its closest sibling browser_list_prompts, which an agent might otherwise reach for to inspect pending dialogs first.

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?

"Without this the page stays blocked" gives a clear condition for when the tool is required, which is exactly the decision an agent needs. It stops short of naming alternatives (e.g. browser_list_prompts to see what is waiting) or of saying when not to call it.

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

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

Goes well beyond the annotations by disclosing the mechanism (document-level preload), the measured before/after behavior, and honest limits — it is not an undetectability promise, and other signals can still expose automation. Reversibility is stated via remove:true. The one gap is it never frames the destructiveHint=true implication (that the patch persists for all future documents until undone).

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 core effect is front-loaded in the first sentence, followed by the measured rationale and the caveat. It is on the denser side, but every sentence — including the 'MEASURED' evidence and the limits clause — carries useful 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 one-parameter toggle with annotations and no output schema, the description supplies everything an agent needs: what changes, why, how to reverse it, and what it does not guarantee.

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

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

Schema coverage is 100% and the single parameter already documents 'default false = install'. The description reinforces this with 'Pass remove:true to undo', adding the undo framing but no syntax or default detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.