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

With no annotations, the description clearly discloses error handling ('Continues on error') and independence of clicks, which is critical behavioral context. However, it does not mention potential side effects like navigation or schema-imposed limits (max 10 clicks), though the maxItems constraint is in the schema.

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

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

The description is three concise sentences, front-loading the main action and then adding key behavioral details. Every sentence earns its place without unnecessary elaboration.

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

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

For a tool with three parameters (one a complex array) and no output schema, the description covers core behavior but leaves ambiguity about the return structure. 'Returns per-click results' is vague; specifying the result format (e.g., success boolean, error string) would make it more 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%, providing clear descriptions for each parameter. The description adds value by explaining the sequential and independent behavior across the 'clicks' array, which helps agents understand how parameter values interact. It does not elaborate on individual parameter selection (e.g., ref vs. selector), but the schema already covers that adequately.

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

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

The description clearly states the verb 'Click multiple elements sequentially', which precisely communicates the action and resource. It distinguishes itself from the sibling 'click' tool by indicating batch processing with independent errors and per-click results.

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 use for multiple independent clicks but does not explicitly compare to the sibling 'click' tool or state when to use alternatives. No 'when not to use' guidance is provided, leaving some ambiguity for an AI agent.

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

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

No annotations are provided, so the description carries full burden. It mentions the tool combines extraction and download, and parameters like concurrency and maxFiles suggest behavior, but it does not disclose potential side effects (e.g., creating files, overwriting) or error conditions. For a batch operation, more transparency is warranted, but it adequately conveys the basic function.

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

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

The description is two sentences, front-loading the primary action and including a helpful usage example. Every word contributes: no redundancy, very efficient.

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

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

With no output schema, the description could have explained what is returned (e.g., list of downloaded files). It covers parameters adequately but lacks mention of return value or error handling. For a batch tool, slightly incomplete but functional.

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 baseline is 3. The description does not add significant meaning beyond the schema, but it contextualizes the parameters by stating the tool extracts from a container and downloads, which aligns with the parameter roles. No extra value, but no deficiency.

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

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

The description clearly states the tool extracts resources from a DOM container and downloads them all, specifying it combines extract_resources + download. This differentiates it from siblings like extract_resources and batch_click.

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

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

The description provides usage examples (downloading images from a chat, PDFs from a table), giving clear context. It does not explicitly state when not to use, but the examples imply the intended use case. Alternatives like extract_resources are implied by the combination mention.

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

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

No annotations provided, so description must disclose behavior. It states the destructive action but lacks details on edge cases (e.g., invalid tabId, multiple sessions). Adequate but not comprehensive.

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

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

Extremely concise: two short sentences that front-load the key action and use-case. No wasted words.

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

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

For a simple tool with no output schema and one parameter, the description adequately explains what it does and when to use it. Could mention if it closes all windows or only the user's session tabs, but overall 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?

Schema coverage is 100%, and the description repeats the schema's description exactly, adding no new meaning beyond what the schema already provides. Baseline score of 3 applies.

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

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

The description clearly states the action ('Close all browser tabs') and the target ('for a user session'), distinguishing it from sibling 'close_tab' which closes a single 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?

Explicitly recommends usage 'when done with a browsing session', but does not mention when not to use it or contrast with alternatives like 'close_tab'.

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

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

With no annotations, the description carries the full burden. It discloses the isolated scope and anti-detection safety feature, which is valuable. It also mentions the API key requirement conditionally. However, it does not describe the return value format, potential side effects of DOM manipulation, or concurrency/error behavior, leaving meaningful gaps.

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

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

The description is brief yet information-dense. It opens with the primary action, then adds scope/safety, use cases, and an auth condition in a structured way. Every sentence serves a purpose and there is 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?

The tool is a JavaScript evaluator, which can have complex return values and side effects. The description covers core purpose and usage, but does not explain what the tool returns (the evaluation result), how errors are surfaced, or whether the script runs synchronously. This leaves some context incomplete.

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 value by providing concrete expression examples and clarifying that tabId comes from create_tab. This helps the agent understand how to format expressions and where to obtain the tabId.

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?

Begins with a specific verb+resource: 'Execute JavaScript in the browser page context'. Clearly distinguishes from sibling tools such as click, type_text, and snapshot by stating its function and scope. Includes concrete use cases ('extracting data not visible in accessibility snapshot', etc.) that reinforce purpose.

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

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

Provides explicit 'Use for:' scenarios, giving clear context on when to invoke this tool. Also notes a prerequisite (CAMOFOX_API_KEY only when browser-server authentication is enabled). However, it does not explicitly mention when NOT to use it or name alternative tools for other operations, such as clicking or navigating.

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

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

No annotations provided, so the description carries the full burden. It discloses the optional selector behavior (returns outerHTML), the auth requirement (CAMOFOX_API_KEY only when auth enabled), and clarifies it operates on the live DOM. It does not explicitly state read-only, but 'Get' implies no mutation. Lacks details on error handling or size limits, but sufficient for a simple getter.

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

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

Three sentences, front-loaded with main purpose, each sentence adds value with no fluff.

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

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

Given the low complexity (2 params, no output schema, no annotations), the description covers purpose, usage context, parameter behavior, and auth requirement. It is complete for an agent to decide and invoke. Minor omission of error/edge-case behavior but not critical.

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

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

Schema covers both parameters with descriptions. The description adds behavioral semantics by explaining that selector returns that element's outerHTML instead of full page, and ties tabId to create_tab already in schema. This exceeds 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?

Description explicitly states 'Get rendered HTML from the live DOM' with a specific verb and resource. It distinguishes itself from snapshot and accessibility tree by targeting SPA/custom-component sites and final DOM state, differentiating it from siblings like snapshot and camofox_query_selector.

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

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

Provides explicit use cases: when snapshot refs are incomplete on SPA/custom-component sites or when final DOM state is needed. Clearly implies snapshot/accessibility tree as alternatives, though it does not name them directly.

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

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

No annotations provided; description only states the basic action without disclosing side effects, prerequisites (e.g., element must be visible), or safety profile, leaving significant behavioral gaps.

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

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

Two short, clear sentences with no wasted words; efficient and front-loaded.

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

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

For a simple hover action with good schema coverage, the description covers the essentials, though it doesn't note if subsequent actions (like waiting or snapshotting) are needed.

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

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

The description adds practical context by emphasizing that either ref or selector should be used, complementing the schema which marks both as optional but does not indicate at least one is needed.

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

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

The description clearly states the action ('hover') and its purpose (trigger tooltips, dropdown menus, or hover states), distinguishing it from click or other interaction tools.

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

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

It mentions using ref or CSS selector, giving some direction on element specification, but lacks explicit guidance on when to use hover over alternatives like click or scroll.

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

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

No annotations are provided, so the description carries the full burden. It discloses the action (press key) and lists typical use cases, but does not cover edge cases like invalid keys or tab IDs, nor does it specify that only single keys are supported. Adequate for a simple action.

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

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

Two sentences: first states purpose, second provides usage guidelines and examples. No wasted words, front-loaded, and efficient.

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

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

No output schema is needed for this simple tool. The description covers the key use cases and common keys, making it complete for an agent to invoke. Minor gaps remain (e.g., handling bad input), but overall 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?

Schema coverage is 100%, so baseline is 3. The description adds value by providing a list of common keys and contextual use cases beyond the schema's parameter descriptions, though 'tabId' lacks extra detail.

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

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

The description clearly states the tool presses a keyboard key and lists specific use cases (submit forms, navigate, etc.), differentiating it from siblings like type_text and click.

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

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

The description explicitly says to use after type_text for common actions like Enter, Tab, Escape, ArrowDown, ArrowUp, etc., and lists common keys. It lacks explicit when-not-to-use, but the guidance is clear and practical.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about authentication ('Requires CAMOFOF_API_KEY only when browser-server authentication is enabled') and that it operates on the 'live DOM'. However, it does not specify whether the operation is read-only, what the exact return payload looks like, or error handling 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 description is two sentences, front-loaded with the main action, and every sentence adds value (function, use case/alternative, auth note). There is zero waste.

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 query tool with 3 parameters and no output schema, the description covers purpose, usage, and authentication context. It could specify more about what 'element details' includes or the return shape, but the provided information is sufficient for basic selection and invocation.

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

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

All three parameters have full schema descriptions (100% coverage), so the baseline is 3. The description adds marginal meaning by mentioning 'element details or a specific attribute' which aligns with the optional 'attribute' parameter, but it does not provide new semantics beyond the schema.

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

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

The description clearly states the tool's function with a specific verb ('Query') and resource ('CSS selector in the live DOM'), and specifies the output ('element details or a specific attribute'). It distinguishes itself from sibling tools like camofox_evaluate_js by positioning it as the targeted inspection alternative without raw evaluate_js.

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

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

The description provides explicit when-to-use guidance: 'Use this for targeted inspection without writing raw evaluate_js.' This names a specific alternative (evaluate_js) and a use case (targeted inspection). It does not mention any exclusions or other alternatives, but the guidance is clear enough for selecting the 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?

No annotations are provided, so the description carries full burden. It mentions the return of 'scroll position metadata to track progress,' which adds behavioral insight. It could be more explicit about side effects, but scrolling is generally benign.

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 purpose and usage condition, no unnecessary words. Every sentence adds value.

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

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

Given no output schema, the description mentions return metadata and provides sufficient context for a scrolling tool. Potential for slightly more detail on return structure, but not critical.

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?

Input schema has 100% description coverage with clear descriptions per parameter. The description adds no additional parameter-specific semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states it scrolls a specific container element (modal dialog, scrollable div, sidebar), using a specific verb+resource. It distinguishes from sibling 'scroll' (page-level scroll) by specifying container-level scrolling.

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 says 'Use when page-level scroll doesn't reach content inside modals or overflow containers,' providing clear context and suggesting an alternative (page-level scroll).

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

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

No annotations provided, so description carries all burden. It discloses composite action (scroll + snapshot), return values (scroll position and snapshot), and the waitMs parameter implies a wait before snapshot. Missing details like side effects or auth needs, but for a straightforward combination tool this is adequate.

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

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

Extremely concise: two sentences with no wasted words. First sentence states the action; second sentence provides context and return values. Information is front-loaded and scannable.

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

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

Covers purpose, usage context, and return values. Does not explain the roles of selector and ref parameters (but schema does). With no output schema, the description compensates by mentioning returns. Overall sufficiently complete for the tool's 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% (every parameter has a description). Description adds no additional semantics beyond what the schema already provides for each parameter. Baseline score of 3 is appropriate.

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

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

Description clearly states the action: scroll a container and take a snapshot. It explicitly combines two sub-tools (scroll_element and snapshot), distinguishing from sibling tools like camofox_scroll_element (only scroll) and snapshot (only snapshot). The use case (lazy content in modals) adds specificity.

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

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

Provides a concrete example ('incrementally loading lazy content in modals e.g. Facebook group post comments'), suggesting when to use. Does not explicitly exclude alternatives (e.g., using separate tools) but the context of sibling tools and the description's 'combines' hint at the trade-off.

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

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

No annotations exist, but the description discloses the specific conditions waited for (DOM, network idle, hydration). However, it does not mention timeout behavior, error handling, or whether the tool returns a success indication, leaving gaps in behavioral transparency.

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

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

The description consists of two concise sentences: the first states the purpose, the second provides usage guidance. Every word adds value with no redundancy or fluff.

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

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

The description covers purpose and usage but lacks details on return value, error behavior (e.g., timeout), and what 'fully ready' entails in edge cases. Given the tool's simplicity and the presence of sibling tools, it is adequate but not fully comprehensive.

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 parameter descriptions, but the description adds meaning by explaining the three waiting criteria (DOM, network, hydration), which enriches understanding of the timeout and waitForNetwork parameters beyond their schema definitions.

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

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

The description clearly states the tool waits for a page to be fully ready (DOM loaded, network idle, framework hydration). It differentiates from sibling wait tools like camofox_wait_for_selector by targeting overall page readiness rather than specific elements or text.

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

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

The description explicitly says 'Use after navigation or actions that trigger page changes,' providing clear context. While it doesn't list exclusions or alternatives, the usage guidance is direct and sufficient for the intended 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?

No annotations are provided, so the description carries the full burden. It discloses the waiting behavior and the API key requirement, but does not mention what happens on timeout or whether it returns a value or throws an exception.

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 concise sentences with no filler. Each sentence adds meaningful information: the main action, when to use it, and the authentication caveat.

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 relatively simple wait-for-selector tool, the description is fairly complete: it explains the purpose, usage, and an edge case (snapshot refs). However, it doesn't describe the return value or error behavior, which would make it fully complete given 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 parameters (tabId, selector, timeout) are well-documented in the schema. The description adds no extra parameter semantics beyond what's in the schema, so the baseline 3 applies.

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

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

The description clearly states the action ('Wait for a CSS selector to appear') and the target resource ('live DOM'). It distinguishes itself from sibling tools like camofox_wait_for_text by focusing on CSS selectors.

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

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

Provides explicit usage context ('for SPA hydration and async content when snapshot refs are incomplete or stale') and guidance to prefer snapshot refs once found. Also notes the conditional API key requirement.

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

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

With no annotations, the description must fully disclose behavior. It states the tool waits for text to appear but omits details like polling interval, scrolling behavior, or timeout error handling. The inclusion of a timeout parameter hints at failure behavior but is not explicit.

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

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

The description is two sentences, front-loaded with the action and followed by relevant use cases. Every word serves a purpose, and there is no redundancy or unnecessary detail.

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

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

The description covers the basic purpose and use cases but lacks details on behavioral aspects (polling, timeout behavior, error handling). Given the tool's simplicity and no output schema, it is moderately complete but could be more explicit about behavior.

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

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

Schema coverage is 100%, so the description adds value by contextualizing the 'text' parameter as waiting for appearance. However, no additional explanation is given for 'tabId' or 'timeout' beyond the schema, leaving some semantic gaps.

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

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

The description clearly states the action ('wait for specific text') and resource ('on the page'), with explicit use cases. It effectively distinguishes this tool from siblings like camofox_wait_for_selector by focusing on text content.

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

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

The description provides clear context for when to use the tool (search results, form submissions, dynamic content). However, it does not explicitly state when not to use it or mention alternative tools (e.g., wait_for_selector) for comparison.

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

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

No annotations provided, so description carries full burden. It only says 'Click an element' without disclosing waiting behavior, navigation triggers, or whether it returns anything. Minimal behavioral info.

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 redundant words. Front-loaded with action, then details. Highly efficient.

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

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

No output schema, so description should cover return values or side effects. It doesn't. Tool is simple but lacks info on what happens after click (e.g., navigation). Barely adequate.

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 baseline is 3. Description adds value by advising to use snapshot for ref discovery, supplementing the schema's parameter descriptions.

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

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

The description clearly states 'Click an element' with specific verb and resource. It distinguishes from siblings like batch_click by mentioning ref or selector. No ambiguity.

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

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

Explicitly advises to use snapshot first to discover refs. Provides clear context but doesn't contrast with alternatives like hover or type_text.

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

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

Without annotations, the description adds value by disclosing that the tool releases resources and frees memory, indicating a destructive but beneficial cleanup action. No mention of error behavior, but acceptable for a simple mutation.

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, direct sentences with no redundant information. Every word serves a purpose.

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

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

The description covers the core action and usage reason. For a simple close operation with no output schema, it is reasonably complete, though it could mention typical return values or error cases.

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

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

Schema coverage is 100%, and the parameter description 'Tab ID from create_tab' is sufficient. The tool description does not add extra parameter context beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action 'close a browser tab' and the resource 'browser tab', distinguishing it from sibling tools like create_tab and list_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?

The description advises 'Always close tabs when done to free memory,' providing a clear usage guideline, though it lacks explicit when-not-to-use or alternative instructions.

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

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

With no annotations, the description carries the full burden. It discloses that each tab gets a unique fingerprint, and explains the behavior of sharing the CLI context. However, it does not mention what the tool returns, whether it opens a new window, or any potential side effects like rate limits.

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

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

The description is a single paragraph of four sentences, front-loading the core action. It is clear and efficient, though a more structured layout (e.g., bullet points for the CLI sharing case) could improve 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?

Given 11 parameters including nested objects and no output schema, the description adequately covers the tool's purpose and CLI context behavior. However, it omits return value information and broader tab lifecycle context, leaving some gap for agent decision-making.

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 context for userId/sessionKey sharing and viewport usage, but does not introduce new meaning beyond the schema's detailed descriptions.

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

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

The description clearly states 'Create a new browser tab with anti-detection fingerprinting'—a specific verb and resource. It distinguishes from siblings like close_tab and navigate by emphasizing fingerprinting and parameter customization.

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 explicit guidance for sharing the CLI default profile using userId 'cli-default' and sessionKey 'default', and notes that this does not attach to an already open CLI tab. However, it does not explicitly compare to alternatives like load_profile or navigate for creating tabs.

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 states it deletes from disk and registry, implying destructiveness, but provides no details on side effects (e.g., whether it's permanent, if permissions are needed, or error handling). With no annotations, more transparency is needed.

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

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

The description is a single short sentence, no wasted words. However, it lacks structure such as usage notes or examples, which would further improve clarity.

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

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

The description is minimal and does not address return values, errors, or expected behavior beyond deletion. For a destructive tool, the agent likely needs to know if it succeeds silently or throws errors, which 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 input schema descriptions already fully explain the parameters (downloadId and userId), so the description adds no extra meaning. Baseline score of 3 is appropriate given 100% schema coverage.

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

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

The description clearly states the action ('Delete'), the resource ('a downloaded file'), and the scope ('from disk and registry'), making it easy to understand what the tool does. It distinguishes from siblings like 'get_download' and 'list_downloads' by the destructive nature.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites or context for safe use. For example, it does not mention checking if the download exists or that deletion is irreversible.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It mentions permanent deletion of cookie data but is ambiguous about what else is deleted (e.g., history, bookmarks). Lacks details on side effects, authorization needs, or error conditions.

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 clearly state the action and permanence. No unnecessary words. However, it could be more informative without additional length, e.g., specifying what exactly is deleted.

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

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

For a simple tool with one required parameter and no output schema, the description is moderately complete. It covers the basic purpose and permanence but lacks details on error handling, prerequisites, and full scope of deletion (profile vs cookies only).

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 already describes the profileId as 'Profile name to delete'. The description adds minimal value by repeating 'saved browser profile' but does not clarify naming conventions, existence requirements, or format validation beyond the schema.

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

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

The description clearly states the action (delete) and the resource (saved browser profile), and it distinguishes from sibling tools like save_profile and load_profile by specifying permanence and disk removal.

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

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

No explicit guidance on when to use or avoid this tool. It does not mention prerequisites (e.g., profile existence) or alternatives (e.g., other profile management tools). The description implies finality but no warning about cascading effects.

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

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

No annotations provided, so description carries full burden. It describes a read operation but lacks details on side effects, permissions, or return behavior. Adequate but not comprehensive.

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

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

Two sentences, front-loaded with core purpose. No wasted words. Highly concise.

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

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

With 9 parameters and no output schema, description is brief. Does not mention return format, error handling, or behavior for edge cases. Adequate but could be more 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% (all parameters have descriptions). Description adds that selector and ref are for scoping, but this is already clear from schema. Minimal added value beyond 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?

Description clearly states verb 'Extract' and resource types 'images, links, media, documents' from a specific DOM container. Distinguishes from siblings like batch_download and get_links by specifying scoped extraction.

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 says when to use: 'Use a CSS selector or element ref from snapshot to scope extraction to a particular section of the page.' Provides example use cases. Does not mention when not to use or alternatives, but sufficient.

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

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

With no annotations, the description should disclose side effects, auth needs, or reliability guarantees. Only 'deterministic' is mentioned, but no further behavioral traits are described.

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

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

The description is a single sentence with no wasted words, but could be slightly more structured by separating purpose from the schema reference.

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

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

Given three parameters and no output schema, the description lacks details about return format, prerequisites (e.g., page already loaded), and potential side effects, making it incomplete for an agent to use 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?

Input schema descriptions cover all parameters, so baseline is 3. The description adds no meaningful extra context beyond what the schema provides; it only repeats the mention of 'camofox-browser'.

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

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

The description clearly states the action 'Extract deterministic structured JSON from a page' and specifies the schema used, which distinguishes it from sibling tools like 'extract_resources' that extract different content.

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

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

No guidance on when to use this tool versus alternatives such as 'camofox_evaluate_js' or 'extract_resources'. The description does not mention prerequisites or context for optimal use.

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

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

No annotations are provided, so the description alone must inform behavior. It discloses the core actions (filling fields and optionally clicking submit) but does not mention side effects, error handling, or whether changes are reversible. With no annotations, this is merely adequate.

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

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

Two concise sentences with no wasted words. The essential information is front-loaded: the tool fills multiple fields in one call, then details the input structure, and ends with the optional submit. This is an excellent use of 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?

Given the moderate complexity (nested objects, 3 parameters, no output schema), the description covers the key points: how to specify fields and the optional submit button. It does not explain order of execution or what happens on errors, but for a form-filling tool this is sufficient. It could be slightly more thorough about failure scenarios.

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

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

Schema coverage is 100%, so the baseline is 3. The description paraphrases the schema (e.g., 'each with a ref or CSS selector and the text to type') but adds minimal extra meaning and slightly misstates that each entry must have a ref or selector, while schema only requires text. It does not compensate for any gaps.

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

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

The description clearly states the tool fills multiple form fields in one call, which distinguishes it from single-field tools like type_text and type_and_submit. The verb 'fill' and resource 'form fields' are specific, and the batch nature is emphasized.

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 use when multiple fields need filling, and the existence of sibling tools like type_text for single fields provides context. However, it doesn't explicitly state when to avoid or list alternatives, missing a chance to clarify the best use case.

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

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

No annotations exist, so the description carries full burden. It clearly explains that images are returned as viewable images, and for non-images, behavior depends on includeContent (metadata only vs base64 inline, max 256KB). It does not address error cases, rate limits, or authentication, but the behavior is well-specified.

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

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

Two sentences, front-loaded with the core action. Every sentence adds value: stating purpose, clarifying image behavior, and providing a recommendation. No wasted words.

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

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

Given no output schema, the description adequately explains return values: images are viewable, non-images either base64 inline (if includeContent true) or metadata only with contentUrl. It does not cover error conditions or specific file type handling, but for a simple retrieval tool, it is 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?

Schema coverage is 100%, so baseline is 3. The description adds meaningful context for includeContent by explaining its effect (base64 inline for non-images, max 256KB) and the default behavior. For downloadId and userId, the description adds no additional meaning beyond the schema, but the includeContent guidance elevates the 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?

The description states 'Get a downloaded file' with specific verb and resource. It distinguishes from siblings like list_downloads and delete_download by focusing on retrieval. The additional detail about images being viewable and guidance for AI agents further clarifies the tool's purpose.

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

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

The description recommends setting includeContent=true for non-image file content, providing explicit guidance on when to use that parameter. However, it does not discuss when to use this tool versus alternatives like list_downloads or delete_download, nor does it indicate 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?

Without annotations, the description carries the burden of behavioral disclosure. It correctly indicates a read operation but does not mention any limitations, side effects, or specifics like pagination or link types. The behavior is minimally transparent.

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

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

The description is extremely concise at two sentences (15 words), with the action front-loaded. Every word adds value; no redundant or filler 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 tool with 4 parameters and no output schema, the description is somewhat incomplete. It hints at return values (URLs and text) but does not specify the exact structure (e.g., array of objects). While adequate, it could be more complete.

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

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

The input schema covers 100% of parameters with descriptions. The tool description does not add additional meaning or nuance beyond the schema, so it meets the baseline for adequate but not enhanced semantics.

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

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

The description clearly states the tool retrieves all hyperlinks from a page, including URLs and text. The action is specific and distinct from sibling tools like extract_resources or click.

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

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

The description mentions it is useful for navigation discovery and site mapping, providing implicit context. However, it does not explicitly state when to use it versus alternatives, nor does it provide when-not-to-use guidance.

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

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

No annotations are provided, so the description must carry the full burden. It implies read-only behavior but does not disclose details such as whether the tool is safe, idempotent, or has any side effects. The description is insufficient for behavioral transparency.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the purpose and lists specific metrics concisely.

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

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

Given the absence of an output schema, the description lists return categories but lacks specifics on shape or format. It is somewhat complete for a simple tool but could be more detailed about the output structure.

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

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

Schema coverage is 100% for the single parameter 'tabId', which is described as 'Tab ID from create_tab'. The description does not add additional meaning beyond the schema, earning a baseline score of 3.

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

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

The description clearly states the verb 'Get' and the resource 'session statistics', listing specific metrics (request counts, active tabs, uptime, performance metrics). It effectively distinguishes this tool from siblings, none of which focus on statistics.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it specify exclusions or context. An agent would have no basis to decide between this and other tools.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses the outcome (new page URL) but lacks details such as whether it navigates only one step, what happens if history is empty, or any side effects (e.g., state loss).

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

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

The description is a single sentence that concisely captures the tool's purpose and output. No redundant information, and every word earns its place.

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

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

For a simple navigation tool with one parameter and no output schema, the description provides sufficient context: the action, the output, and the connection to browser history. It is complete enough for an agent to understand usage, though it could mention the single-step nature.

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

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

The input schema has 100% description coverage for its single parameter (tabId), which is already well-described. The description does not add further semantic value beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Navigate backward in browser history') and compares it to the familiar 'Back button'. It also specifies the output ('Returns new page URL'). This distinguishes it from sibling tools like go_forward and navigate.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives. However, the action is self-explanatory, and the sibling go_forward implies the opposite direction. No exclusion criteria or prerequisites are mentioned.

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

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

The description notes it returns the new page URL, but no annotations are provided. It does not describe behavior when there is no forward history, potential errors, or side effects (e.g., page load).

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

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

The description is a single concise sentence that conveys essential information without fluff.

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

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

For a simple tool, the description is fairly complete but omits error handling details (e.g., no forward history). With no annotations, more behavioral context would be beneficial.

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

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

The input schema has 100% coverage for the single parameter (tabId), and the description adds no additional meaning beyond what the schema provides.

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

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

The description explicitly states the tool 'navigates forward in browser history' and calls it 'Forward button', which clearly distinguishes it from siblings like go_back and navigate.

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

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

The purpose implies when to use (going forward in history), but it does not explicitly mention when not to use or suggest alternatives like go_back or navigate.

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

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

Discloses that the tool imports cookies and restores sessions, implying a write operation, but does not detail whether it overwrites existing cookies, requires any special permissions, or has side effects. Given no annotations, the description provides moderate but incomplete behavioral insight.

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 succinct sentences deliver the core purpose and parameter hints without redundancy. Every sentence contributes value.

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

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

Covers basic functionality and required parameters but omits what happens during import (e.g., merge vs. replace), error conditions, and absence of output schema leaves agents guessing about return values.

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 description's mention of 'JSON string array' for cookies and 'userId' requirement adds no new information. It does not clarify the format of the cookie array or the purpose of 'tabId' beyond what the schema already states.

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

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

Explicitly states 'Import cookies for authenticated sessions' with a clear verb and resource, and further explains it restores login sessions without re-authentication. It is distinct from all sibling tools, none of which directly handle cookies.

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

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

Lacks guidance on when to use this tool versus alternatives like 'load_profile' or manual authentication. No mention of prerequisites beyond 'Requires userId', and no exclusions or negative cases.

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

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

No annotations are provided, so the description carries the full burden. It discloses that each download includes a contentUrl for retrieval, which adds value beyond the schema. However, it does not disclose any behavioral traits such as data freshness, pagination behavior, or potential side effects. The description is adequate but not rich.

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 succinct with two sentences. The first sentence covers purpose and filters, and the second adds a key output detail. No unnecessary words – 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?

Given the number of parameters (10) and no output schema, the description is fairly complete by stating filtering criteria and a key output field. However, it lacks mention of pagination defaults (limit/offset) and sort behavior, though these are in the schema. The description could be slightly more comprehensive, but it covers the essentials.

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 description does not need to repeat parameter details. It mentions filtering capabilities, which are already in the schema, and adds the context of contentUrl in the output. This adds marginal value, justifying a baseline score of 3.

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

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

The description clearly states the tool's purpose: listing downloaded files with optional filtering. It specifies the verb 'List' and the resource 'downloaded files', and distinguishes from siblings like 'get_download' (singular) and 'delete_download'. The mention of specific filter criteria and contentUrl adds precision.

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

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

The description implies usage by listing available filters, but does not explicitly state when to use this tool versus alternatives. However, given the sibling set, no other listing tool exists, so the context is clear. A brief statement of when not to use (e.g., for a single download) would improve this dimension.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states 'list all available', indicating a read-only operation with no side effects. This is transparent for a simple list tool.

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

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

The description is two sentences, front-loaded with the action, and contains no extraneous information. Every word serves a purpose.

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

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

The tool is straightforward: a parameterless list operation. The description adequately specifies the content of presets (locale, timezone, geolocation), making it complete even without an 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?

There are no parameters in the input schema, and schema coverage is 100% (vacuously). The description does not need to add parameter detail, and its mention of what presets include is sufficient given the tool's simplicity.

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

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

The description clearly states the tool lists all available geo presets, specifying their content (locale, timezone, optional geolocation). This distinguishes it from sibling tools that perform actions like clicking or navigating.

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 this tool is for retrieving available presets, but lacks explicit guidance on when to use it versus alternatives or any prerequisites. The context is clear enough for a simple list operation.

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

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

No annotations are provided, so the description carries the full burden. It accurately describes a read-only operation with scope ('all saved browser profiles') and lists output fields, but does not disclose any potential restrictions like authentication or rate limits. Still, it's sufficiently transparent for a simple listing tool.

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

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

The description is two concise sentences, front-loaded with the main action and followed by details. No extraneous words, earning its place.

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

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

Given no parameters and no output schema, the description fully covers what the tool does and what it returns. No additional context is needed.

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

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

The input schema has zero parameters, so the description does not need to explain parameters. Baseline score of 4 is appropriate as there is no missing information.

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

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

The description clearly states the tool lists all saved browser profiles and specifies the metadata fields (profile names, cookie counts, save dates, descriptions), making it distinct from sibling tools like load_profile or delete_profile.

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 this tool is for listing profiles, but does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. The context is simple enough that it's acceptable but not fully helpful.

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

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

No annotations are provided, but the description implies a non-destructive read operation. It does not mention performance or limits, but for a straightforward listing tool, this is adequate.

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

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

Two short sentences, each meaningful. No superfluous information. The structure is front-loaded with the core purpose.

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

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

Given no parameters, no output schema, and the simplicity of listing tabs, the description fully satisfies the need. It specifies what fields are returned (URLs and titles).

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 description adds no parameter meaning—this is appropriate. The baseline for 0 parameters is 4.

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

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

The description clearly states the action (list), the resource (open browser tabs), and the returned data (URLs and titles). It distinguishes itself from sibling tools like close_tab or create_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?

The description suggests two use cases: discovering available tabs and verifying tab state. While it doesn't explicitly exclude alternate tools, this is sufficient for a simple list operation.

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

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

With no annotations, the description partially discloses behavior: it restores login sessions without re-authentication. However, it does not explain error cases (e.g., missing profile) or side effects like overwriting existing cookies. The description adds some value but lacks full transparency.

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

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

The description is concise: two sentences that front-load the core purpose and end with a usage hint. Every sentence adds value with no redundancy.

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

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

Given the tool's simplicity (2 required parameters, no output schema, no annotations), the description is sufficiently complete. It covers purpose and usage context. It could mention handling of missing profiles, but this is not critical for basic understanding.

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 no additional meaning beyond what the schema already provides for 'profileId' and 'tabId'. It does not explain how profile names are resolved or validated.

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

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

The description clearly states the tool loads a saved profile's cookies into an active tab, using the specific verb 'load' and identifying the resource and action. It distinguishes itself from sibling tools like 'save_profile' and 'import_cookies' by focusing on restoring login sessions.

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

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

The description provides explicit usage guidance: 'Use after create_tab to restore saved state.' This tells the agent when to invoke the tool, though it does not mention when not to use it or 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?

Discloses two key behaviours: waiting for page load and returning the final URL after redirects. Given no annotations, this adds important context about the tool's operation.

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

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

Three sentences that are front-loaded with the main purpose, no wasted words. Efficient and easy to parse.

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

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

The description covers the essential aspects of the tool: its function, prerequisite, and return value behavior. No output schema exists, but the return value is described (final URL). Adequate for a simple tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds minimal extra context (e.g., 'Tab ID from create_tab') but mostly restates schema info.

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

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

The description clearly states the verb 'navigate' and the resource 'a tab to a URL'. It distinguishes itself from the sibling 'navigate_and_snapshot' by focusing only on navigation without additional actions.

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

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

Explicitly instructs to use 'create_tab first, then navigate', providing a clear prerequisite. However, it does not mention alternatives like 'navigate_and_snapshot' or when not to use this 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?

No annotations provided, so the description must carry the full burden. It states it combines actions but does not detail behavior on errors, page load waiting, or the exact sequence. The optional waitForText is mentioned but not fully explained (e.g., whether it waits for the text before snapshot).

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

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

Two concise sentences that quickly convey the core purpose and that it combines multiple actions. No unnecessary words, effectively 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?

No output schema exists, so the description should explain the return value. It only says 'return the page snapshot' without detailing format or content. Also lacks prerequisites (though schema covers tabId).

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 adds no additional meaning beyond what the schema already provides for parameters like tabId, url, waitForText, and timeout.

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

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

The description clearly states the tool navigates to a URL and returns a snapshot, explicitly mentioning it combines three actions (navigate, wait, snapshot). This differentiates it from sibling tools like navigate, wait, and snapshot.

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

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

The description explains the tool combines multiple steps into one call, implying use when all three are needed together. However, it does not provide explicit guidance on when not to use it or mention alternatives beyond the sibling names.

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

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

With no annotations, the description carries full burden. It indicates a reload operation but does not disclose whether it waits for completion, potential side effects (e.g., unsaved data loss), or if it's asynchronous.

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

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

The description is two sentences long, efficient, and front-loaded with the core action. No fluff.

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

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

For a simple one-param tool with no output schema, the description covers purpose and usage context. It lacks details on return behavior or error handling, but is adequate for the 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?

Since schema coverage is 100% and the description adds no extra meaning beyond the schema's parameter description, it meets the baseline. No enrichment provided.

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

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

The description clearly states the tool reloads the current page, using a specific verb and resource. It distinguishes itself from siblings like go_back and go_forward which navigate history.

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 mentions usefulness when page state is stale or after changes, giving clear context. However, it does not explicitly state when not to use or compare with 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?

Explains the transformation from temporary blob URL to base64 data URI, but given no annotations, could further disclose limitations (e.g., size caps, cross-origin restrictions, no side effects like destructive behavior).

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

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

Two concise sentences with zero filler: one sentence states purpose, the second adds context about blob URLs and the conversion result.

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?

Adequately describes the problem and solution; lacks output format details (e.g., return structure or error handling) but reasonable for a simple conversion tool without 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 coverage is 100% (all parameters documented in schema), so baseline is 3; description does not add extra parameter details beyond 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?

Describes the specific action 'resolve blob: URLs to downloadable base64 data', explains what blob URLs are, and clearly distinguishes from any sibling tool (no other tool does this conversion).

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

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

Provides context on when to use (encountering blob URLs from Telegram, WhatsApp, Discord that cannot be downloaded directly), but lacks explicit when-not-to-use or alternative tool names.

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

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

With no annotations provided, the description carries full burden. It discloses that the tool saves cookies to disk and requires an active tab, but lacks details on overwriting behavior or potential 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?

Three short sentences convey the action, benefit, and usage context with no redundancy. Fully front-loaded.

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

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

Given the simple nature of the tool (3 parameters, no output schema, no annotations), the description provides enough context for an agent to use it correctly, though it omits details like return value and overwrite behavior.

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

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

Schema coverage is 100% with adequate descriptions for each parameter. The tool description adds value with usage context but does not significantly enhance parameter understanding 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 uses a specific verb ('save') and resource ('browser cookies from an active tab to a named profile'), clearly distinguishing it from siblings like load_profile, import_cookies, and delete_profile.

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 'Use after login to save authenticated state,' providing clear context for when to use it. Does not mention when not to use or explicitly name alternatives, but the context is sufficient.

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

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

With no annotations, the description carries the full burden. It discloses the output format (base64 PNG), the viewport vs. full-page behavior via the fullPage flag, and the cost trade-off (token inefficiency). It could mention that the return is a string or indicate side effects, but for a screenshot tool this is sufficient.

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 concise sentences with no fluff. The action is front-loaded, and each sentence adds value: action/format, parameter guidance, and usage preference.

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

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

Despite no output schema, the description explains the return format (base64 PNG) and the tool's scope. It covers purpose, usage, and key parameter behavior, making it complete for a two-parameter screenshot tool.

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

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

Schema coverage is 100% for both parameters. The description adds some context (e.g., 'viewport' vs 'full-page') but largely restates what the schema already documents, so baseline 3 is appropriate.

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

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

The description clearly states the tool's action: 'Take a viewport or full-page visual screenshot in base64 PNG.' It also distinguishes from siblings by noting the visual nature and explicitly contrasting with 'snapshot for most tasks.'

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 when-to-use guidance is provided: 'Use ONLY for visual verification (CSS, layout, proof). Prefer snapshot for most tasks — much more token-efficient.' This directly addresses alternatives and exclusions.

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

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

With no annotations, the description carries full burden. It only states scrolling action and parameters, lacking details on animation, blocking, or 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?

Two sentences, front-loaded with purpose, and efficient – no unnecessary words.

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

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

The description is adequate for a simple scroll tool, but lacks differentiation from sibling tools like scroll_and_snapshot and does not specify if a return value exists.

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

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

Schema coverage is 100%, and the description adds no extra meaning beyond what the schema provides for tabId, direction, and amount.

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

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

The description clearly states the tool scrolls a page by pixel amount, specifying direction and default. It is distinct from element-scrolling siblings like camofox_scroll_element, though it doesn't explicitly differentiate.

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 tells when to use it ('reveal content below the fold or navigate long pages'), but does not mention when not to use or provide alternatives.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only states the basic action (scroll then snapshot) and does not mention parameters like direction, amount, or waitMs that affect behavior. The schema provides details, but the description lacks contextual behavioral traits.

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

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

The description is a single sentence that conveys the core purpose and use case without unnecessary words. It is highly concise and efficient.

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

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

Given the tool has 4 parameters, no annotations, and no output schema, the description is insufficient. It does not explain parameter usage, behavior on scroll direction, or what happens after snapshot. The tool combines two actions but lacks completeness for an AI agent to use 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 input schema has 100% coverage for 4 parameters. The description adds no additional meaning or context to the parameters (e.g., what 'tabId' refers to, or how 'amount' is used). Baseline 3 is appropriate since schema covers the parameter semantics.

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

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

The description clearly states 'Scroll the page and take a snapshot' and specifies the use case 'revealing content below the fold.' It distinguishes itself from sibling tools like 'scroll' (only scrolls) and 'snapshot' (only snapshot), making the purpose 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 includes 'Useful for revealing content below the fold,' which implies when to use the tool. However, it does not provide explicit when-not-to-use guidance or mention alternative tools like combining 'scroll' and 'snapshot' separately.

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 accurately portrays a read-only status check, returning version and status info. Without annotations, the description sufficiently indicates no destructive side effects. It could be more explicit about being non-destructive, but the nature of 'check' and 'status' implies safety.

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 consists of two efficient sentences with no redundant words. It is front-loaded with the core purpose and provides essential return value details.

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 health check with no parameters and no output schema, the description covers the purpose, usage guidance, and return values. It could specify the format of the returned fields (e.g., version string), but it is not critical.

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

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

The input schema has 0 parameters, so no parameter description is needed. The baseline for 0 parameters is 4 per the scoring rules, and the description does not need to add more.

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

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

The description clearly states the verb 'Check' and the resource 'Camofox server health and browser connection', and explicitly lists return values (version, browser status, active tab count). This distinguishes it from the many action-oriented sibling tools (e.g., click, navigate) which perform browser operations rather than health checks.

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 'Call first to verify server is running' provides explicit guidance on when to use this tool (before other operations). It implies a prerequisite step, but does not explicitly list when not to use or discuss alternative tools, which would raise the score to 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?

Discloses key behavioral trait: refs come from accessibility tree, so custom SPA elements may be missing. Also mentions token-efficiency. However, no annotations exist, and the description does not cover auth requirements, side effects, or whether the tool works on non-loaded tabs. Still, it provides useful operational context.

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

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

Three sentences with no redundancy: first states purpose, second lists return values, third gives fallback guidance. Compact and information-dense, perfectly 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?

Despite no output schema, the description adequately explains return format (element refs, roles, names, values) and mentions token-efficiency. It also addresses known limitations (missing SPA elements) and provides fallback options, making it complete for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add new parameter-level details beyond what the schema already provides for 'tabId' and 'offset'. The mention of 'Use nextOffset from previous response' is already in the schema's offset description, so no added value.

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

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

Clearly states 'Get accessibility tree snapshot' and distinguishes as 'the PRIMARY way to read page content'. Unlike siblings like screenshot or camofox_get_page_html, it specifically mentions returning element refs, roles, names, and values, making its purpose 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?

Explicitly recommends using this tool over screenshot and provides specific fallback alternatives when custom SPA elements are missing: 'fall back to CSS selectors, camofox_wait_for_selector, or camofox_get_page_html when needed.' This gives clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains that switching to headed/virtual mode shows the browser window and includes a vncUrl for interaction, and that the response contains a tabsInvalidated field indicating whether tabs need recreation. This provides transparency beyond a mere toggle action.

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

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

The description is three sentences, efficiently covering purpose, usage, and response behavior. It is front-loaded with the main action and provides necessary details without wordiness. A slight reduction in length could be possible, but current structure is clear and functional.

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

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

Given the tool's simplicity (toggling display mode), the description is fairly complete. It explains the two main use cases (CAPTCHA, resolution), and decodes response fields (vncUrl, tabsInvalidated). It lacks error handling or edge cases like permission errors, but for a toggle tool with two parameters, it covers essential aspects.

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 covers both parameters with descriptions (100% coverage). The description adds value by explaining the effect of headless values (false→headed, true→headless, virtual→virtual display) and mentions response behaviors (vncUrl, tabsInvalidated) that are not in the schema, enriching parameter understanding.

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 explicitly states the tool toggles browser display mode between headless and headed, which is a specific verb-resource pair. It also mentions the virtual mode from the schema. This clearly distinguishes it from sibling tools that perform other browser actions like clicking, scrolling, or navigation.

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

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

The description provides clear usage guidance: use headed mode when encountering CAPTCHAs or issues requiring visual interaction, and switch back to headless after resolving. It also explains how to handle the response (vncUrl, tabsInvalidated). While it doesn't explicitly list when-not-to-use, the context is sufficient.

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

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

No annotations are provided, so the description carries the full burden. It states that it types text and presses a key (default Enter), but does not disclose whether it replaces existing text or appends, or what happens after keypress (e.g., form submission, navigation). More behavioral detail would be beneficial.

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, no redundant information. Every sentence adds value: the first describes the operation, the second provides a use case.

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 5 parameters and no output schema, the description is somewhat incomplete. It does not explain that ref or selector are needed to identify the field, and that tabId is required for context. The agent might miss how to correctly specify the target element.

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 adds minimal additional meaning beyond the schema, only reinforcing the default key. It does not elaborate on how to use ref versus selector to target the element, which could be helpful.

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

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

The description clearly states the action (type text and press a key) and the target (a field), and identifies its use case for search boxes and single-field forms. It effectively distinguishes from sibling tools like type_text (which only types) and fill_form (which handles multiple fields).

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 contextual guidance by noting it's useful for search boxes and single-field forms, implying it should not be used for multi-field forms. However, it does not explicitly mention when not to use it or list alternatives, but the context is sufficient for an agent to differentiate from siblings.

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

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

With no annotations, the description carries the full burden. It discloses that text replaces existing content and implies a dependency on a prior snapshot. However, it does not specify if the operation simulates keystrokes or sets the value directly, nor does it mention potential side effects or event triggers.

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

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

The description is two sentences, front-loaded with the core action ('Type text into an input field'), and every sentence adds essential information. No redundant or irrelevant content.

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

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

Given the lack of output schema and annotations, the description covers the main aspects: what it does, how to specify the target, and a prerequisite (snapshot). It could be more complete by detailing the return value or success behavior, but it is sufficient for a simple action tool.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by clarifying that 'ref' comes from a snapshot, that 'selector' is a CSS selector, and by recommending the order of preference. This guidance goes beyond the schema definitions.

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

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

The description clearly states it types text into an input field, and distinguishes between using a ref or a CSS selector, providing specific guidance on when to use each. This makes the purpose highly clear and distinguishes it from sibling tools.

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

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

The description provides explicit guidelines on when to use ref vs selector (e.g., 'Use ref when available; otherwise use selector when snapshot doesn't assign refs'). It also advises to call snapshot first. However, it does not mention alternative tools for similar tasks (like fill_form), so it lacks explicit exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that results are not directly returned and must be read via snapshot, and that it relies on 14 browser macros. This is significant behavioral context beyond the schema.

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

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

The description is two sentences, front-loaded with the core action, and every word adds value. The list of macros is necessary for enumerating options, and the snapshot instruction is a critical callout. No fluff or repetition.

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

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

Given the tool's simplicity and the lack of an output schema, the description is largely complete: it identifies the search engines, explains the follow-up snapshot step, and implicitly signals that tabId comes from create_tab (already in schema). It doesn't cover error scenarios, but for a standard search tool this is adequate.

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

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

The schema already describes all three parameters fully (query, tabId, engine) with 100% coverage. The description adds only the list of valid engines, which duplicates the enum, and no new semantic meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool performs searches via a specific set of 14 named macros, distinguishing it from navigation and snapshot tools. The verb 'Search' plus the explicit list of engines makes the purpose 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 gives a clear procedural cue: 'Call snapshot after to read results,' which tells the agent the immediate next step. However, it does not explicitly contrast with alternative tools like 'navigate' or 'snapshot', though the workflow implication is sufficient for basic use.

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

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

No annotations provided; description only states it returns timestamped text and no tab required. Missing disclosure about API limitations, rate limits, or video requirements. Limited behavioral transparency for a tool with no annotations.

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 fluff. Essential information provided efficiently.

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

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

Given no output schema, description minimally covers return format. Lacks error handling details or prerequisites. Adequate for simple tool but not fully comprehensive.

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 descriptions fully cover both parameters. Description adds little beyond expressing output format. Baseline 3 given 100% coverage.

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

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

Specific verb 'Extract' and resource 'transcript from a YouTube video'. No sibling overlap, clearly describes 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?

Does not explicitly state when to use vs alternatives. 'No tab required' is a minor usage note but insufficient guidance on context or prerequisites.

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