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

No annotations provided, so description carries full burden. It discloses key behaviors: preserves active/queued tabs, never returns sensitive data (URLs, titles, cookies, etc.), and defaults to dry-run mode. Missing details on session handling but 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, front-loaded with purpose. Every sentence earns its place: purpose, behavioral constraints, and default mode. 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?

For a 5-parameter tool with no output schema and no annotations, description explains purpose, behavior, and limitations. Lacks details on session handling (e.g., closeEmptySessions) and return value format, but overall 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% (baseline 3). Description adds context like 'Defaults to dry-run mode' reinforcing dryRun parameter, and 'proactive memory-pressure cleanup' provides context for minIdleMs/maxTabsToClose. No elaboration per parameter, but schema is complete.

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 ('closes idle tabs') and resource ('tabs') with specific context: proactive memory-pressure cleanup, preserving active/queued operations. Distinguishes from siblings like camofox_close_tab_group or camofox_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?

Description implies use for memory cleanup but does not explicitly state when to use or when not to use, nor provide alternatives beyond the sibling list. No usage exclusions or 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 fully disclose behavior. It only says 'Click an element' without mentioning side effects, error states, visibility requirements, or the existence of the 'doubleClick' parameter (which is in the schema). This is insufficient.

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, making it concise but at the expense of missing critical information. It is not front-loaded with essential details and lacks structure (e.g., parameter explanations). It could be more informative without being verbose.

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

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

Given no annotations, no output schema, 6 parameters with low schema coverage, and a complex nested coordinates object, the description is incomplete. It does not explain the doubleClick behavior, required fields, or what the tool returns, leaving the agent with significant gaps.

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

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

Schema description coverage is only 33%, meaning most parameters (tabId, userId, coordinates, doubleClick) lack descriptions. The tool description only mentions the three targeting methods, omitting required parameters like tabId and userId and the doubleClick option. It does not adequately compensate for the schema 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 'Click an element' and lists three distinct targeting methods (ref, CSS selector, coordinates), which is a specific verb+resource. It distinguishes from sibling tools like camofox_type (typing) and camofox_press_key (key presses) that have different actions.

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

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

The description implies usage for clicking elements but provides no explicit guidance on when to use this tool versus alternatives, or when to choose one targeting method over another. No exclusions or alternative tool mentions are given.

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

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

With no annotations, the description carries full burden. It discloses the action (close tabs) but omits details like reversibility, confirmation, or effect on browser state. Minimal beyond stating the resource.

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 front-loaded information. No redundancy, but could include more substance without losing conciseness.

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?

Adequate for a simple tool, but missing context such as prerequisites (active browser, valid listItemId) and side effects. Output schema not expected.

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

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

Schema description coverage is 0%. The description only hints at listItemId's meaning (tab group) but does not explain userId or provide details like format or how to obtain values.

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 that the tool closes all tabs in a group using a listItemId. It uses specific verbs and resources, distinguishing it from sibling tools like camofox_create_tab or camofox_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?

No guidance on when to use this tool versus alternatives (e.g., camofox_cleanup_idle_tabs). No when-not-to-use or prerequisite information provided.

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

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

No annotations are provided, so the description carries full burden. It discloses the trace parameter constraint (must be set on first tab) and mentions the return value (tabId). However, it does not explain what happens if no session exists, whether a browser is automatically started, or error scenarios.

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: a title line and a short paragraph. It uses clear formatting with a 'PREFERRED' label. Every sentence adds value, though it could be slightly more compact without losing information.

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

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

Given 5 parameters, no output schema, and no annotations, the description covers purpose, preferred usage, return value, and a key behavioral note about the trace parameter. However, it lacks details on session initialization, default behavior, error handling, and the exact return format, leaving gaps for an agent.

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

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

Parameter schema coverage is 100% with descriptions in the schema. The description adds value by noting that 'trace' must be set on first tab creation and that 'listItemId' is a legacy alias for sessionKey. However, for most parameters, the description does not add meaning beyond what the schema already 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 clearly states the tool creates a new tab using Camoufox anti-detection browser, and returns a tabId. It distinguishes itself from siblings by emphasizing that Camoufox tools bypass bot detection on sites like Google and Amazon, contrasting with Chrome/the built-in browser.

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

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

The description explicitly says 'PREFERRED: Use camofox tools instead of Chrome/the built-in browser' and explains why (bypass bot detection). It provides clear context for when to use this tool, though it does not explicitly state when not to use it beyond implying 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 that the action deletes (destructive), but no annotations provided. Does not mention permanence, recovery, or side effects. Basic transparency adequate for a simple delete.

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 wasted words. Straightforward and to the point.

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

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

Adequate for a simple delete operation with 2 params and no output schema. Could mention permanence, but overall covers the essential scope.

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%, with both userId and filename described. 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?

Clearly states 'Delete a trace file' and specifies it removes a Playwright trace zip from the server. Distinguishes from sibling tools like camofox_download_trace and camofox_list_traces.

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

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

Implied usage (when you need to delete a trace), but no explicit guidance on when not to use or alternatives. Lacks prerequisites or context for selecting this over other tools.

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

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

With no annotations provided, the description carries the full burden. It discloses destructive behavior ('closes all tabs and cleans up state'), but lacks details such as whether the action is reversible, what happens to unsaved data, or if any confirmation is required. The description is functional but not thorough.

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

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

The description is extremely concise: two sentences that convey the core action and its effects. No extraneous text. Front-loads the verb and resource immediately.

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

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

For a simple tool with one parameter and no output schema, the description covers the basic functionality. It explains what is destroyed (session, tabs, state) and identifies the required input. Minor gaps exist (e.g., return value, error conditions), but the description is adequate for typical use.

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

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

The only parameter, userId, is mentioned in the description ('for the given userId'), but no additional context is given about its format, source, or implications. The schema coverage is 0%, so the description should compensate but does so minimally. The agent might not know how to obtain the correct userId.

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 'Destroy a user session' and elaborates with 'Closes all tabs and cleans up state for the given userId,' making the verb and resource explicit. It distinguishes from sibling tools like camofox_stop_browser (which stops the browser process) and camofox_cleanup_idle_tabs (which targets idle tabs rather than a full session).

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not mention prerequisites, typical scenarios, or when not to use it. For example, it does not contrast with camofox_stop_browser or explain if destroy_session is needed before or after other operations.

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 says 'streams a zip' but doesn't detail whether the download returns a file or URL, if authentication is needed, or any side effects. The mention of trace.playwright.dev provides context but not behavioral specifics.

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, no filler. The first sentence states the purpose, the second adds context about the output format. 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?

Without an output schema or annotations, the tool is underspecified. It doesn't explain the response format (binary stream, URL, etc.), error scenarios, or that the trace file must be obtained via list_traces. For a tool with two required params, this is insufficient.

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 descriptive parameter names and descriptions ('Session owner identifier', 'Trace zip filename'). The description adds no additional meaning beyond 'trace file' and 'trace zip', 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 'Download a trace file' and specifies 'Streams a Playwright trace zip for viewing in trace.playwright.dev.' This distinguishes it from sibling tools like camofox_list_traces (listing) and camofox_delete_trace (deletion).

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

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

No guidance on when to use this tool vs alternatives. It doesn't explain prerequisites (e.g., trace must exist) or that it's for downloading a specific trace by filename. No mention of 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?

No annotations are provided, so the description carries the full burden. It discloses that JS runs in page context and returns a result, but omits details like synchronous/asynchronous behavior, error handling, security implications, or potential page modifications. 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?

The description is three sentences with no fluff. The first sentence states the action, and subsequent sentences clarify purpose and use cases. Every sentence adds value, and it is front-loaded with the key verb and resource.

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

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

Given the absence of an output schema and annotations, the description addresses purpose and use cases but lacks details on return format, error behavior, prerequisites (e.g., tab must exist), and potential side effects. Adequate for basic understanding but incomplete for safe invocation.

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

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

Schema coverage is low (33%), only the 'expression' parameter has a description. The tool description adds general context but does not explain the meaning of 'tabId' or 'userId' beyond what the schema provides. It fails to compensate for the missing 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?

Description clearly states the verb 'evaluate/execute' and resource 'JavaScript in a tab'. It provides specific use cases (injecting scripts, reading page state, calling web app APIs) and distinguishes from sibling tools that perform other browser interactions.

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?

Description lists when to use the tool (for injecting scripts, reading state, etc.) but does not explicitly state when not to use it or mention alternative tools for similar tasks. The usage context is implied but lacks exclusions.

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

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

No annotations provided; description carries full burden. Describes the extraction mechanism and prerequisite but omits details like error handling (e.g., missing refs), whether extraction is synchronous, or if it modifies page state.

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

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

Two effective sentences with no fluff. Front-loaded with purpose and followed by a critical prerequisite. 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 tool with 3 required params, nested schema, and no output schema, the description explains input format and prerequisite well. Missing details about output shape (though inferable from schema) and potential errors.

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 33%; only the 'schema' parameter has a description. The description adds meaningful details about the schema structure and x-ref usage, but 'tabId' and 'userId' lack explanation. Partially compensates for low 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 it extracts structured data using a JSON Schema with x-ref hints. It distinguishes from sibling tools (e.g., snapshot, click) by focusing on data extraction from the current page and explicitly requiring a prior snapshot call.

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 call camofox_snapshot first to populate the ref table. Provides clear context for when to use but does not mention when not to use 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?

No annotations are provided, so the description must carry full burden. It only states it navigates back, but fails to disclose that this is a state-changing operation (mutates tab history position), whether it may fail gracefully, or any side effects. Minimal behavioral 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?

Extremely concise: two sentences that immediately convey the tool's purpose without wasted words. The core action is front-loaded with 'Go back'.

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 2 required parameters with no schema descriptions and no output schema, the description provides insufficient context. It does not explain parameter roles or return value, leaving the agent to guess.

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 no meaning to the two parameters (tabId, userId). Since schema description coverage is 0%, the agent has no clue what these parameters represent. The description should at least indicate that tabId identifies the tab and userId identifies the user.

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 a Camoufox tab back to the previous page, using the verb 'navigate' and specifying the resource 'tab'. This distinguishes it from siblings like camofox_navigate (go to URL) and camofox_click (click elements).

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

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

No guidance on when to use this tool vs alternatives. The description does not mention prerequisites, such as requiring an existing history entry, or when not to use it (e.g., if the tab has no history).

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 implies a read-only operation without side effects, consistent with a health check. However, it does not explicitly state that it is non-destructive or safe to call frequently. With no annotations, more behavioral context would be helpful.

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?

Very concise at two lines, but the first line 'Health check' is somewhat redundant with the tool name. The second line adds detail efficiently. 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?

The description covers the key aspects of output but lacks details on format, frequency of data, or whether failures are aggregated. Given no output schema, more completeness would help.

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?

No parameters present, and schema coverage is 100%. The description adds value by indicating what the output contains (tab/session counts, failure tracking), which is 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 it provides detailed health information including tab/session counts and failure tracking. The name 'health' reinforces the purpose. Distinguishes from sibling tools like camofox_metrics by mentioning specific health details, though not explicitly.

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

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

No guidance on when to use this tool versus alternatives (e.g., camofox_server_status or camofox_metrics). The description does not specify appropriate contexts or preconditions.

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

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

No annotations are provided, so the description must fully cover behavioral traits. It states the tool modifies a user session by importing cookies but does not disclose whether existing cookies are replaced, if validation occurs, or any size/format limitations. More detail is needed for a mutation tool.

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

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

The description is concise at two sentences with a clear primary purpose and a usage example. The first sentence essentially restates the tool name, which is slightly redundant, but overall it is 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?

The description covers the main action and a key prerequisite, but lacks information about return values or side effects (e.g., whether the operation returns success/failure). For a tool with two parameters and no output schema, this is minimally adequate but 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?

With 50% schema description coverage (userId has a brief description, cookie properties have none), the description adds no additional meaning. It only repeats that cookies are imported but does not clarify the structure or constraints (e.g., required domain format). The agent must rely on schema field names only.

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

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

The description clearly states that the tool imports cookies into a user session, provides a concrete use case (skipping interactive login on LinkedIn), and the action is distinct from all sibling tools which are about browser automation (navigation, clicks, screenshots, etc.) without cookie management.

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 indicates the tool is for authenticated browsing (e.g., to skip login) and mentions a production prerequisite (BearerAuth). However, it does not explicitly specify when not to use this tool or suggest alternatives, though no direct alternative exists among 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?

No annotations are provided, so the description must fully disclose behavior. It only states listing tabs without mentioning read-only nature, side effects, or permissions required. For a simple listing tool, this is insufficient.

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 has two sentences where the first is redundant ('List open tabs' repeats the title). It could be merged into one sentence. It is short but not optimally 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?

For a simple tool with one optional parameter and no output schema, the description is mostly adequate but lacks details about the output (e.g., what fields are returned for each tab). This omission leaves agents unsure of the return structure.

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

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

The input schema covers the single parameter userId with a description 'Filter by session owner.' The description adds no additional meaning beyond this, 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 uses a specific verb 'List' and resource 'open tabs', clearly indicating the tool's function. It is distinct from siblings like camofox_list_traces, which lists traces, and camofox_create_tab, which creates a 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?

No guidance on when to use this tool versus alternatives such as camofox_navigate or camofox_snapshot. The description only states what it does, not when it is appropriate.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It discloses that the tool returns all trace zip files sorted newest first. However, it does not mention behavior with invalid userId or empty results, which is a minor gap.

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

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

The description is two concise sentences, front-loaded with the action, and contains no extraneous words. Every sentence contributes meaning.

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 listing tool with one parameter and no output schema, the description adequately covers what is returned (trace zip files) and ordering. However, it lacks detail on the response structure (e.g., file names vs. metadata), which would be helpful given the absence of 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?

Schema coverage is 100%, so baseline is 3. The description reinforces the parameter's purpose ('user session') but adds no additional format or constraint beyond the schema's description of 'Session owner identifier.' No extra semantic value.

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

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

The description clearly states the tool lists trace files, specifies the resource (Playwright trace zip files), the context (given user session), and the ordering (newest first). This distinguishes it from sibling tools like download or delete.

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

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

The description implies usage for listing traces before downloading or deleting, but does not explicitly state when to use this tool versus alternatives or provide when-not scenarios. The guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description must fully disclose behavior. It states the tool returns Prometheus format and requires an environment variable, but does not mention any side effects, error conditions, or safety profile (e.g., read-only nature).

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 with no wasted words. The key information (returns Prometheus metrics, requires env var) is front-loaded 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?

For a tool with no parameters and no output schema, the description covers the core functionality and a key requirement. However, it could be more complete by clarifying the exact metrics included or the format's structure, which would help an agent interpret the output.

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

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

The input schema has no parameters (coverage 100%), so the baseline is 3. The description does not need to add parameter info, but it also does not provide any additional 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 returns Prometheus metrics in text exposition format, which is a specific verb+resource. However, it does not distinguish it from sibling tools like camofox_health or camofox_server_status, which might also provide server information.

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 a prerequisite (PROMETHEUS_ENABLED=1), providing some usage context. But it does not explicitly state when to use this tool versus alternatives, leaving the agent to infer.

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

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

With no annotations provided, the description must disclose behavioral traits. It mentions auto-creating tabs if tabId is not found, but misses other important details like potential destructive actions (navigating away can lose state), permission requirements, or 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 consists of two concise, front-loaded sentences. Every sentence adds value: the first states the core purpose, the second adds context on usage and tab auto-creation. 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 has 7 parameters and no output schema, the description is incomplete. It does not cover return values, error conditions, or behavior for malformed inputs, leaving an agent without sufficient context to invoke it reliably.

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

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

The description adds meaning to macro and query parameters by listing examples and explaining their purpose. However, schema coverage is only 29%, and the description does not explain url, userId, sessionKey, or listItemId, leaving 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 navigates a tab to a URL or search macro, with specific examples like @google_search. It distinguishes itself from siblings by mentioning it is preferred over Chrome/the built-in browser for bot detection, but does not explicitly contrast with camofox_go_back.

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 when to use this tool (for sites with bot detection) and mentions auto-creation of tabs, but does not specify when not to use it or provide alternatives among 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, description should disclose behavior. It only states the action without mentioning side effects, error conditions, or return behavior. Minimal transparency.

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

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

Description is short (two sentences) and front-loads the purpose. Could be slightly more concise by merging, but overall efficient.

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

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

For a simple keypress tool, the description covers the basic action. However, it lacks explanation of required parameters beyond key, and has no output schema description. Adequate but with gaps.

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

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

Schema description coverage is low (33%); only 'key' has a description. The tool description adds no further meaning for 'tabId' or 'userId', and does not compensate for missing schema descriptions.

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

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

Description clearly states the tool presses a keyboard key and gives examples like Enter, Escape, Tab. However, it does not differentiate from sibling tool 'camofox_type' which likely types a string, so the distinction is implicit.

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

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

No guidance on when to use this tool versus alternatives like 'camofox_click' or 'camofox_type'. No context on prerequisites or scenarios.

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

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

No annotations are present, so the description must fully disclose behavioral traits. It states the tool captures a screenshot but does not clarify if it captures only the viewport or full page, any side effects (e.g., scroll position changes), or limitations like size constraints. This is insufficient 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?

The description is very short with two sentences, each providing useful information. However, it lacks essential details, making it under-specified rather than appropriately 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?

Given the absence of annotations and output schema, the description should provide more context, such as return value details (e.g., encoding specifics, size limits) or usage notes. It fails to fully inform the agent for correct invocation.

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

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

Schema description coverage is 0%, and the description adds no meaning to the parameters (tabId, userId). It does not explain what these parameters represent or how to obtain them, leaving the agent with no guidance.

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 ('Take a screenshot') and the resource ('a Camoufox page'), and specifies the output format (base64-encoded PNG). However, it does not differentiate from the sibling tool 'camofox_snapshot', which may have a similar 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?

No guidance is provided on when to use this tool versus alternatives (e.g., camofox_snapshot) or prerequisites (e.g., needing a tabId from camofox_list_tabs). The context for using the tool is absent.

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 bears full responsibility. It mentions returning 'basic server liveness and browser state' but doesn't confirm read-only behavior, side effects, or required permissions.

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

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

Two short sentences with no waste. Highly concise 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?

Adequate for a simple status tool with no parameters and no output schema. However, it lacks detail on the exact output format and what 'browser state' encompasses.

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?

No parameters exist; schema coverage is trivially 100%. The description adds no parameter info, but with 0 parameters baseline 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 tool returns server liveness and browser state, matching the tool name. However, it does not differentiate from sibling 'camofox_health', which likely has overlapping functionality.

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

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

No guidance on when to use this tool versus alternatives like 'camofox_health' or 'camofox_metrics'. No context for 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?

Discloses that it triggers a real layout reflow and uses Playwright's setViewportSize. No annotations exist, so description carries full burden; could mention side effects (e.g., scroll reset) or permissions.

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

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

Two efficient sentences: front-loaded with purpose, then technical implementation detail. 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?

No output schema, no annotations, and parameter semantics are absent. Missing return value, error conditions, prerequisites (e.g., valid tabId). Incomplete for a tool with 4 required params.

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

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

Schema coverage is 0%, but description provides no details on parameters (width, height, tabId, userId). Agent gets only parameter names from schema, no units or constraints.

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

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

Clearly states the tool sets viewport size via Playwright's setViewportSize, triggering real layout reflow. Distinguishes from sibling tools like navigate, click, etc., and contrasts with window.resizeTo.

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 for responsive testing and notes that window.resizeTo is ineffective on non-popup windows. However, lacks explicit when-not-to-use or alternative 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 provided, so description carries full burden. It discloses pagination behavior (truncation, hasMore, nextOffset) and optional screenshot, but does not discuss side effects, permissions, or rate limits. The disclosed traits are relevant but incomplete.

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 with two sentences. The first sentence states the purpose, the second explains pagination and optional screenshot. It is front-loaded and clear, though could be broken into structured bullet points.

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 description should explain return format. It mentions response fields hasMore and nextOffset but does not describe the snapshot structure (e.g., content format, element refs). For an interactive tool, more detail on output would be helpful.

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 low (20%) and only offset has a description. The description clarifies includeScreenshot (boolean string) and offset (character offset), but does not explain tabId or userId beyond being required. It adds moderate value over the schema.

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

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

The description clearly states the tool gets an accessibility snapshot of a tab with element refs for interaction, and distinguishes it from screenshot tools by mentioning optional screenshot and pagination. However, it does not explicitly contrast with other sibling tools like camofox_extract_structured_data.

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

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

The description implies usage for interacting with a page via element refs and mentions pagination for large pages, but lacks explicit guidance on when not to use this tool or alternatives. The context is clear but no exclusions are given.

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

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

Given no annotations, the description carries the burden. It discloses key behaviors: starts the browser, ensures running, idempotent. Could mention prerequisites or potential side effects, but overall 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?

Two concise sentences with no extra words. First sentence states action, second adds clarifying behavior (idempotent). Efficient and well-structured.

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 parameters and no output schema, the description is complete: it states the purpose, behavior, and key property (idempotence). No gaps.

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

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

No parameters exist, so baseline 4 is appropriate. The description does not need to add parameter 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 explicitly states 'Start the browser' and clarifies it ensures the browser process is running and is idempotent. This clearly distinguishes it from sibling tools like camofox_stop_browser.

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

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

The description implies usage when wanting to start or ensure the browser is running, but does not provide explicit when-to-use or when-not-to-use guidance, nor mention alternatives among 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 discloses the key behavior (stop browser, close sessions) and the authentication requirement, but does not mention irreversibility or side effects.

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

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

Two sentences, front-loaded with action and resource, every sentence adds value with 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?

Fully sufficient for a zero-parameter tool with no output schema; covers purpose and a key requirement.

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?

No parameters exist, so schema coverage is 100%. Baseline is 4 per guidelines, and description adds no redundant 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?

Clearly states 'Stop the browser' and explains it closes all sessions, distinguishing it from siblings like start_browser and destroy_session.

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?

Mentions the required x-admin-key header, providing context for when to use, but does not explicitly exclude alternatives or specify when not to use.

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

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

With no annotations, the description bears full responsibility. It does not disclose whether typing replaces content, default behaviors of clear/submit, or any side effects (e.g., scrolling, events). Only basic typing behavior is implied.

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-loading the core purpose. Every word contributes meaning, 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?

Given 7 parameters, no output schema, and no annotations, the description is too minimal. It omits key behavioral details (clear/submit flags, default behavior) and does not explain the role of required parameters like tabId and userId.

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

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

Schema coverage is only 29%, but the description adds value by explaining ref/selector as targeting mechanisms (focused element or specific ref/selector). However, parameters like text, tabId, userId are left undefined 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 types text into an element, specifying it can be a focused element or targeted via ref/selector. It distinguishes itself from sibling tools like click and press_key by focusing on text input.

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

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

No guidance is provided on when to use this tool vs alternatives like press_key or evaluate. There is no mention of prerequisites or context for 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 present, so description must disclose behavior. It does not specify what happens if the selector is already present, error handling on timeout, return value, or relationship between selector and timeout (e.g., are both optional? exclusive?).

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

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

The description is short but slightly redundant, stating 'Wait for a selector or timeout' followed by a similar sentence. Could be more concise by combining.

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, no annotations, and 4 parameters with low schema coverage, the description fails to clarify return values, behavior when both selector and timeout are provided, or prerequisites. Important gaps remain.

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

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

Schema description coverage is only 25% (timeout described). The description adds 'CSS selector' for the selector parameter, but does not explain tabId, userId, or the format/syntax of selector. Minimal 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?

The description clearly states it waits for a CSS selector or timeout, specifying the resource (Camoufox tab) and the actions (wait, appear). It distinguishes from sibling tools that perform navigation or clicks.

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 when needing to wait for an element before further actions, but lacks explicit when-not or alternative tools. No exclusions or context for when to use versus other tools.

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