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 mentions that the tool 'Returns an updated snapshot,' which adds some context about output behavior, but fails to address critical aspects like whether this action is safe (non-destructive), requires specific permissions, or has side effects (e.g., affecting 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?

The description is appropriately sized and front-loaded, with the core purpose stated first ('Navigate back in browser history. Returns an updated snapshot.') followed by parameter details. Every sentence earns its place without 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 the tool's low complexity (one parameter) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the action and parameter semantics adequately, though it lacks usage guidelines and fuller behavioral context, which are minor 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?

The description includes an 'Args' section that explains the 'page_id' parameter as 'Target page ID,' adding meaning beyond the schema's minimal coverage (0%). Since there is only one parameter, this compensates well, though it could provide more detail (e.g., format or source of the ID).

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 with a specific verb ('Navigate back') and resource ('browser history'), and distinguishes it from siblings like 'cloak_forward' by specifying direction. However, it doesn't explicitly differentiate from other navigation-related tools like 'cloak_navigate' beyond the 'back' action.

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. The description lacks context about prerequisites (e.g., requires an existing page with history), exclusions, or comparisons to siblings like 'cloak_forward' or 'cloak_navigate' for general navigation.

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 mentions that the tool returns an updated snapshot, which is useful, but does not disclose critical behavioral traits such as whether this action requires specific page states, if it's idempotent, potential error conditions, or performance implications. For a mutation tool with zero annotation coverage, this is a significant 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 front-loaded with the core purpose in the first sentence, followed by a clear Args section that efficiently documents parameters. Every sentence earns its place with no wasted words, making it easy to scan and understand quickly.

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 an output schema (which covers return values), the description is reasonably complete for a mutation tool. It explains the action, parameters, and return, but lacks details on prerequisites, error handling, or behavioral nuances, which are important given the absence of annotations and the tool's interactive 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?

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'page_id' is the 'Target page ID', 'ref' is the 'Ref ID from snapshot', and 'checked' determines whether to check or uncheck. This clarifies the semantics beyond the bare schema, though it could provide more detail on ref ID format or page_id 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?

The description clearly states the specific action ('Check or uncheck a checkbox/radio by ref ID') and the resource ('checkbox/radio'), distinguishing it from siblings like cloak_click or cloak_select by focusing on toggle operations rather than generic interactions. It explicitly mentions the return value ('Returns an updated snapshot'), which further clarifies its 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 implies usage for interacting with checkboxes/radios via ref IDs, but does not explicitly state when to use this tool versus alternatives like cloak_click for general clicks or cloak_select for dropdowns. It provides basic context but lacks explicit exclusions or comparisons with sibling 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 key behavioral traits: auto-retries once if the element moved and returns an updated snapshot. However, it doesn't cover other important aspects like error handling (e.g., what happens if the element doesn't exist), performance (e.g., timeouts), or side effects (e.g., page navigation after clicking).

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by behavioral details and parameter explanations. Every sentence adds value without redundancy, and the structure is clear with a brief intro and an 'Args:' section.

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 moderate complexity (interactive element clicking), no annotations, and an output schema (which handles return values), the description is fairly complete. It covers purpose, behavior, and parameters, but lacks context on integration with sibling tools (e.g., dependency on cloak_snapshot) and error scenarios, which would enhance completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics: 'page_id: Target page ID' and 'ref: Ref ID from snapshot (e.g., '@e5' or 'e5')', including examples. This clarifies what the parameters represent beyond their schema titles ('Page Id', 'Ref'), though it doesn't detail format constraints (e.g., page_id structure).

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: 'Click an element by its [@eN] ref ID from cloak_snapshot.' It specifies the verb (click), resource (element), and source (snapshot). However, it doesn't explicitly differentiate from sibling tools like cloak_hover or cloak_select, which likely perform similar interactions on 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?

The description implies usage by referencing 'cloak_snapshot' as the source for ref IDs, suggesting this tool should be used after taking a snapshot. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., cloak_hover for hovering, cloak_select for selecting), nor does it mention prerequisites like needing a valid page_id from cloak_list_pages or cloak_launch.

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 effectively describes the tool's behavior ('release all resources') and cleanup action, though it lacks details on error handling or confirmation of closure. No contradictions exist, as annotations are absent.

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 highly concise and front-loaded, consisting of two clear sentences: one stating the action and another providing usage guidance. Every sentence earns its place with no wasted words, making it efficient and easy to understand.

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 low complexity (0 parameters, no annotations, but with an output schema), the description is mostly complete. It covers purpose and usage well, but lacks details on output or error scenarios. The output schema mitigates some gaps, but behavioral aspects could be more fully described.

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 with 100% coverage, so no parameter documentation is needed. The description adds value by implying the tool requires no inputs, aligning with the schema, and providing context about its cleanup role, justifying a baseline above 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 specific action ('Close the stealth browser') and resource ('stealth browser'), distinguishing it from siblings like 'cloak_close_page' (which closes a page, not the browser) and 'cloak_launch' (which opens the browser). It explicitly defines the tool's purpose beyond just the name.

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 with 'Always call when done,' indicating when to use this tool (after completing browser operations) and implying when not to use it (during active browser use). This distinguishes it from alternatives like 'cloak_close_page' for partial cleanup.

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 of behavioral disclosure. It states the action ('Close') but doesn't explain what happens when a page is closed (e.g., whether it's destructive, if the page session ends, error conditions, or side effects). For a mutation tool with zero annotation coverage, this is a significant gap in 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 extremely concise and front-loaded, with the core purpose in the first sentence and parameter details in a brief 'Args' section. Every sentence earns its place without redundancy, making it easy for an agent to parse quickly. No wasted words or 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?

Given the tool's moderate complexity (a mutation with one parameter), no annotations, but an output schema exists (which handles return values), the description is minimally adequate. It covers the basic action and parameter but lacks behavioral details (e.g., effects, errors) and usage context. The output schema mitigates some gaps, but overall completeness is limited 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?

The description adds meaningful context for the single parameter 'page_id' by specifying it's 'Page ID to close,' which clarifies its role beyond the schema's generic 'Page Id' title. With 0% schema description coverage, this compensates well, though it doesn't detail ID format or sourcing (e.g., from 'cloak_list_pages'). A 5 would require more specifics like examples 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?

The description clearly states the action ('Close') and target ('a specific page by ID'), making the purpose immediately understandable. It distinguishes from siblings like 'cloak_close' (which might close something else) and 'cloak_list_pages' (which lists pages). However, it doesn't specify what 'close' means operationally (e.g., terminating a browser tab vs. hiding a UI element), leaving some ambiguity compared to a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an open page), exclusions (e.g., not for closing other resources), or related tools like 'cloak_launch' or 'cloak_new_page' for context. The agent must infer usage from the tool name and sibling list alone.

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

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

No annotations are provided, so the description carries full burden. It mentions executing JavaScript and returning results but lacks critical behavioral details: whether it runs in a sandbox, error handling, security implications, performance impact, or if it can modify page state. This is inadequate for a tool that executes arbitrary code.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a structured Args section. It's efficient with minimal waste, though the Args formatting could be more integrated. Every sentence adds value, but slight improvement in flow is possible.

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 complexity (executing arbitrary JavaScript), no annotations, and an output schema (which handles return values), the description is partially complete. It covers the basic operation but misses safety warnings, execution context details, and error scenarios, which are crucial for such a powerful tool.

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

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

Schema description coverage is 0%, so the description must compensate. It lists both parameters (page_id, expression) and briefly explains them ('Target page ID', 'JavaScript expression to evaluate'), adding basic meaning beyond the schema's titles. However, it doesn't detail format constraints (e.g., valid page_id sources, expression limits), 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 specific action ('Execute JavaScript in the page context') and the resource ('page context'), distinguishing it from sibling tools like cloak_click or cloak_type that perform different browser interactions. It directly answers what the tool does without ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an open page), exclusions, or compare it to similar tools like cloak_read_page for reading content. Usage context is implied but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'Returns an updated snapshot', which adds some behavioral context about the output. However, it doesn't disclose important traits like whether this requires an active browser session, what happens if no forward history exists, or any performance considerations. For a navigation tool with zero annotation coverage, this leaves significant gaps in understanding its 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 appropriately sized with two sentences: one stating the purpose and behavior, and another documenting the parameter. It's front-loaded with the core functionality. While efficient, the parameter documentation could be integrated more seamlessly rather than as a separate Args section.

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

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

Given that there's an output schema (which should document the return format), the description doesn't need to explain return values in detail. However, for a browser navigation tool with no annotations and minimal parameter explanation, the description should do more to explain the operational context - what constitutes 'forward' navigation, how this relates to browser state, and what happens in edge cases. It's adequate but has clear gaps.

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

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

The description includes an Args section that documents the single parameter 'page_id: Target page ID.' With schema description coverage at 0%, this parameter documentation in the description is essential. However, it doesn't add much meaning beyond what's implied by the parameter name - it doesn't explain what a page ID is, how to obtain it, or format requirements. The description compensates for the schema gap but minimally.

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: 'Navigate forward in browser history' with the specific verb 'Navigate' and resource 'browser history'. It distinguishes from siblings like cloak_back (backward navigation) and cloak_navigate (general navigation), but doesn't explicitly mention these distinctions. The description is specific about the action but could be more explicit about sibling differentiation.

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

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

The description implies usage context through 'Navigate forward in browser history', suggesting it should be used when there's forward history available. However, it doesn't provide explicit guidance on when to use this vs. alternatives like cloak_back or cloak_navigate, nor does it mention prerequisites or exclusions. The context is implied but not clearly articulated.

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 mentions the action and return value but lacks critical behavioral details: it doesn't specify if hovering triggers side effects (e.g., tooltips, dropdowns), whether it's idempotent, error conditions (e.g., invalid ref), or performance implications. The description is minimal and misses key 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?

The description is concise and front-loaded: the first sentence states the purpose and return value, followed by parameter explanations. There's no wasted text, and the structure is clear. However, it could be slightly more efficient by integrating parameter details into the main sentence.

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 parameters with 0% schema coverage and an output schema (which handles return values), the description is moderately complete. It covers the basic action and parameters but lacks context on integration with siblings (e.g., dependency on cloak_snapshot), error handling, and side effects. For a tool in a browser automation suite, this leaves gaps in usability.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description adds basic semantics: 'page_id: Target page ID' and 'ref: Ref ID from snapshot', explaining what each parameter represents. However, it doesn't provide format examples, constraints, or how to obtain these values (e.g., from cloak_snapshot). This partial compensation justifies a baseline 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 clearly states the action ('Hover over an element') and the resource ('by ref ID'), and mentions the return value ('Returns an updated snapshot'). It distinguishes from siblings like cloak_click or cloak_press_key by specifying the hover interaction. However, it doesn't explicitly differentiate from all siblings (e.g., cloak_check might also involve hovering).

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. It doesn't mention prerequisites (e.g., needing a snapshot from cloak_snapshot first), nor does it specify scenarios where hovering is appropriate over other interactions like clicking or typing. The context is implied but not 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?

With no annotations provided, the description carries full burden and does well by explaining behavioral traits: it discloses that anti-detection is ON by default, describes what the browser passes (Cloudflare Turnstile, reCAPTCHA, etc.), and provides practical warnings about aggressive sites needing headed mode. It doesn't cover rate limits or error handling, but gives substantial 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?

The description is appropriately sized for a complex tool with 15 parameters. It's well-structured with a clear purpose statement followed by organized parameter documentation. Some sentences could be tighter (e.g., the CloakBrowser capabilities list is detailed but necessary), but overall it's efficient and front-loaded with critical 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 the tool's complexity (15 parameters, no annotations, but has output schema), the description is quite complete. It explains what the tool does, how to configure it, and provides practical guidance. The output schema existence means return values don't need explanation. It could benefit from more sibling differentiation and error handling info, but covers most essential context.

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

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

With 0% schema description coverage and 15 parameters, the description fully compensates by providing detailed semantic explanations for every parameter. Each parameter gets clear usage guidance, examples, defaults, and practical advice (e.g., 'Residential recommended' for proxy, fallback behaviors for viewport). This adds significant value beyond the bare 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 specific action ('Launch a stealth CloakBrowser instance') and resource ('CloakBrowser'), distinguishing it from sibling tools like cloak_navigate or cloak_check. It provides technical details about what CloakBrowser is (source-patched Chromium) and what anti-detection capabilities it has, making the purpose highly specific.

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 context through parameter explanations (e.g., 'Some aggressive sites need headed mode'), but doesn't explicitly state when to use this tool versus alternatives like cloak_new_page or cloak_back. It provides practical guidance within parameters but lacks overall usage context relative to 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 carries the full burden. It states the tool lists pages but doesn't disclose behavioral traits such as whether it returns only active pages, if there are rate limits, how it handles errors, or the format of the output (though an output schema exists). For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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?

The description is a single, clear sentence that front-loads the core action ('List all open pages') and specifies the returned data ('IDs and URLs'). There is zero waste, and every word earns its place, making it highly concise 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?

Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally adequate. However, with no annotations and siblings that might overlap (e.g., cloak_read_page), it lacks context on usage scenarios, error handling, or behavioral nuances. It meets basic needs but could be more complete for agent selection.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here. A baseline score of 4 is given as it efficiently handles the lack of parameters without unnecessary elaboration.

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 ('List') and resource ('all open pages'), specifying what information is returned ('IDs and URLs'). It distinguishes from siblings like cloak_navigate or cloak_new_page by focusing on listing existing pages rather than navigation or creation. However, it doesn't explicitly differentiate from cloak_read_page, which might also retrieve page 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., whether a browser must be launched first), exclusions, or comparisons to siblings like cloak_read_page. It's a basic statement of function without contextual usage advice.

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

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

With no annotations provided, the description carries the full burden and does well by disclosing key behaviors: auto-waits for page settlement (network idle + DOM stable), handles Cloudflare challenges with extra wait time, and returns an updated snapshot. However, it lacks details on error handling, rate limits, or authentication needs, which could be important for a navigation tool.

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

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

The description is front-loaded with the core purpose and key behaviors in the first sentence, followed by specific handling details and a clear Args section. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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 moderate complexity (navigation with auto-wait and Cloudflare handling), no annotations, 0% schema coverage, but an output schema exists (implied by 'Returns an updated snapshot'), the description is mostly complete. It covers purpose, behavior, and parameters, but could benefit from more context on errors or prerequisites, though the output schema reduces the need to explain 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 0%, so the description must compensate. It lists the three parameters (page_id, url, timeout) and provides basic semantics (e.g., 'Target page ID', 'URL to navigate to', 'Navigation timeout in milliseconds'), but does not add deeper meaning like format constraints, examples, or edge cases. This is adequate but minimal, meeting the baseline 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 the specific action ('Navigate to a URL') and distinguishes it from siblings by mentioning auto-waiting for page settlement and handling Cloudflare challenges, unlike tools like cloak_back or cloak_forward which imply navigation but without these details. It specifies the resource (a page via page_id) and outcome (returns an updated 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 provides clear context for when to use this tool—for navigating to URLs with auto-wait and Cloudflare handling—but does not explicitly state when not to use it or name alternatives. For example, it doesn't clarify if cloak_back/forward are for browser history navigation versus this direct URL navigation, leaving some ambiguity.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool opens a new page/tab and optionally navigates, but doesn't describe what happens after creation (e.g., whether it becomes the active page, if it's isolated, or if there are limits on concurrent pages). For a tool that likely interacts with browser state, this is a significant gap in transparency, though it at least indicates the core 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 appropriately sized and front-loaded: the first sentence states the core purpose, and the second clarifies the optional parameter. The 'Args:' section is structured but minimal, avoiding redundancy. Every sentence earns its place with no wasted words, making it highly concise and well-organized.

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 low complexity (1 optional parameter) and the presence of an output schema (which likely covers return values), the description is somewhat complete but has gaps. It explains the basic action and parameter, but lacks behavioral details (e.g., page management) and usage guidelines relative to siblings. For a simple tool, this is adequate but not fully comprehensive, aligning with a minimum viable score.

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 meaningful context for the single parameter 'url': it explains that it's optional ('Optionally navigate to a URL') and specifies its purpose ('URL to navigate to after creating the page'). Since schema description coverage is 0% (the schema only lists 'url' with a title 'Url'), this compensates well by clarifying semantics beyond the bare schema, though it doesn't detail format constraints like valid URL patterns.

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: 'Open a new browser page/tab. Optionally navigate to a URL.' This specifies the verb ('Open') and resource ('new browser page/tab'), with an optional navigation action. However, it doesn't explicitly differentiate from siblings like 'cloak_navigate' (which might navigate an existing page) or 'cloak_launch' (which might launch a browser instance), so it doesn't reach the highest clarity level.

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. It doesn't mention when to choose 'cloak_new_page' over 'cloak_navigate' (for existing pages) or 'cloak_launch' (for starting a browser), nor does it specify prerequisites or exclusions. The only implied usage is for creating new pages, but this is basic and lacks explicit context.

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

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

With no annotations provided, the description carries the full burden. It discloses that the action returns 'an updated snapshot', which is useful behavioral context about the output. However, it doesn't mention side effects (e.g., whether it triggers page navigation or changes state), error conditions, or performance implications. The description adds some value but misses key behavioral details 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 front-loaded with the core action in the first sentence, followed by return value and parameter details in a structured format. Every sentence earns its place with no wasted words, making it highly efficient and easy to scan.

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 moderate complexity (2 parameters, mutation action), no annotations, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose, parameters, and output context. However, for a mutation tool, it could better address safety, errors, or interaction with sibling tools to reach full completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for both parameters: 'page_id' as 'Target page ID' and 'key' as 'Key name (DOM KeyboardEvent key)', including an example format for the key. This adds meaningful context beyond the bare schema, though it could elaborate on valid key values 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?

The description clearly states the action ('Press a keyboard key') and target ('Enter, Tab, Escape, ArrowDown, etc.'), making the purpose immediately understandable. It distinguishes from siblings like 'cloak_type' (typing text) and 'cloak_click' (mouse clicks), though it doesn't explicitly name these alternatives. The description is specific but could be slightly more precise about distinguishing from all keyboard-related siblings.

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

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

The description implies usage for pressing specific keys (e.g., navigation keys) rather than typing text, which differentiates it from 'cloak_type'. However, it lacks explicit guidance on when to use this tool versus alternatives like 'cloak_enter' (if it existed) or other keyboard actions. No exclusions or prerequisites are mentioned, leaving some ambiguity in context.

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

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

With no annotations provided, the description carries full burden. It discloses key behavioral traits: content cleaning (strips navigation, ads, footers), token efficiency (60-80% savings vs raw HTML), and output format (markdown). However, it doesn't mention error conditions, performance characteristics beyond efficiency, or what happens with invalid page IDs.

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

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

The description is well-structured and front-loaded with the core purpose. Every sentence earns its place: first states what it does, second provides usage context, third describes cleaning behavior, fourth explains efficiency benefit. The parameter section is clearly separated and 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 tool has an output schema (which handles return values), no annotations, and 2 parameters with 0% schema coverage, the description does well. It covers purpose, usage context, behavioral traits, and parameter meaning. The main gap is lack of error handling or edge case information, but for a read-only content extraction tool, this is reasonably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaningful context for both parameters: 'page_id: Target page ID' and 'max_length: Max characters to return (default: 50000)'. This adds practical understanding beyond the bare schema, though it doesn't explain page ID format or max_length enforcement behavior.

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

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

The description clearly states the tool's purpose with specific verbs ('Get', 'Strips', 'returns') and resource ('page content as clean, readable markdown'). It distinguishes from siblings by focusing on content extraction rather than navigation, interaction, or page management like cloak_navigate, cloak_click, or cloak_list_pages.

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 this tool ('Best for reading articles, docs, search results, or any content-heavy page') and mentions efficiency benefits. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings, though the use case implies it's for content extraction rather than page manipulation.

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 effectively describes what the tool does (takes annotated screenshots with numbered elements), mentions the output format (file path to saved PNG, element count), and explains the relationship with cloak_snapshot. However, it doesn't mention potential side effects like file system changes or performance implications.

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 perfectly structured and concise: purpose statement first, usage guidelines second, return values third, and parameters last. Every sentence earns its place with no wasted words, and information is front-loaded appropriately.

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 complexity (visual capture with annotations), no annotations, and the presence of an output schema (which covers return values), the description is mostly complete. It explains purpose, usage, parameters, and the relationship with sibling tools. The main gap is lack of behavioral details like file storage location or performance characteristics.

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

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

With 0% schema description coverage and 2 parameters, the description compensates well by explaining both parameters: 'page_id: Target page ID' and 'full_page: Capture entire scrollable page (default: viewport only)'. It provides clear semantic meaning beyond what the bare schema offers, though it doesn't elaborate on format constraints for page_id.

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 specific action ('Take an annotated screenshot with element indices overlaid') and distinguishes it from its sibling tool cloak_snapshot by specifying it's for VISUAL context like images, charts, CAPTCHAs, or layout. It provides a clear verb+resource combination that differentiates it from other tools in the list.

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 states when to use this tool ('Use when you need VISUAL context — images, charts, CAPTCHAs, or layout') and when not to use it ('For most interactions, prefer cloak_snapshot() instead'), providing clear alternatives and context for tool selection.

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 of behavioral disclosure. It mentions that scrolling returns an 'updated snapshot,' hinting at a visual update, but lacks details on permissions, rate limits, side effects (e.g., if scrolling affects page state), or error handling. For a mutation tool (scrolling changes view) with zero annotation coverage, this is a significant 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 appropriately sized and front-loaded: the first sentence states the core action and outcome. The Args section is structured but could be more integrated. There's minimal waste, though it could be slightly more cohesive (e.g., merging the Args into the main text).

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

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

Given 3 parameters, no annotations, and an output schema (which handles return values), the description is moderately complete. It covers the basic action and parameters but lacks behavioral context (e.g., scrolling effects, error cases) and usage guidelines. For a tool in a browser automation context with siblings, it should do more to be fully 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 description coverage is 0%, so the description must compensate. It lists parameters (page_id, direction, amount) and provides some semantics: direction accepts 'up' or 'down', and amount is in pixels. However, it doesn't explain page_id context (e.g., from cloak_list_pages) or constraints (e.g., amount limits). With 3 parameters and low schema coverage, this adds value but incompletely.

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: 'Scroll the page. Returns an updated snapshot.' This specifies the verb ('scroll') and resource ('page'), and distinguishes it from siblings like cloak_navigate (navigation) or cloak_screenshot (capturing images). However, it doesn't explicitly differentiate from all scrolling-related tools if any existed, keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an open page), exclusions (e.g., not for scrolling within elements), or compare it to siblings like cloak_read_page or cloak_snapshot for similar outcomes. Usage is implied but not explicitly stated.

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

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

No annotations are provided, so the description carries full burden. It mentions 'Returns an updated snapshot,' which hints at output behavior, but lacks details on permissions, side effects (e.g., if selection triggers page changes), error handling, or rate limits. For a mutation tool (selecting implies changing state) with zero annotation coverage, 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 front-loaded with the core purpose, followed by a brief note on returns and a parameter list. It's efficient with no wasted sentences, though the parameter section could be more integrated. Overall, it's appropriately sized for a tool with 5 parameters.

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 complexity (a UI interaction tool with 5 parameters, no annotations, but has output schema), the description is partially complete. It covers the basic action and parameters but lacks behavioral context, usage guidelines, and error details. The output schema existence means return values don't need explanation, but other gaps remain for a mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate. It lists parameters and explains that 'value,' 'label,' or 'index' are alternatives for selection, adding meaning beyond the schema's basic types. However, it doesn't clarify parameter interactions (e.g., if multiple are provided) or constraints, leaving gaps. Given the coverage gap, this is a minimal improvement.

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: 'Select a dropdown option by ref ID' with the verb 'select' and resource 'dropdown option'. It distinguishes from siblings like cloak_click or cloak_type by focusing specifically on dropdown selection. However, it doesn't explicitly contrast with other selection-related tools (none in the sibling list), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a page loaded via cloak_navigate or cloak_launch), nor does it differentiate from similar actions like cloak_click on dropdowns. The sibling tools include many UI interaction tools, but no context is given for choosing this one.

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 effectively describes key behaviors: returns interactive elements with ref IDs for use with other cloak_* tools, explains performance characteristics ('FASTER, CHEAPER, and MORE RELIABLE'), and describes the difference between full=True and full=False modes. It doesn't mention error conditions or rate limits, but provides substantial 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?

The description is efficiently structured with clear sections: purpose statement, usage guidance, parameter explanations, and comparative advantages. Every sentence earns its place, with no redundant information. The information is front-loaded with the most important guidance ('Call this BEFORE interacting with a page') appearing early.

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 complexity (accessibility tree capture with parameter options) and the presence of an output schema (which means return values don't need explanation), the description is complete. It covers purpose, usage guidelines, parameter semantics, behavioral characteristics, and sibling tool relationships. The description provides all necessary context for effective tool 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?

With 0% schema description coverage, the description fully compensates by explaining all three parameters: page_id ('Target page ID from cloak_launch or cloak_new_page'), full ('Include text content alongside interactive elements' with detailed explanation of full=False vs full=True), and max_length ('Max characters to return' with default value). The description adds significant meaning beyond the bare 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 purpose: 'Capture the page's accessibility tree' and specifies it's 'the PRIMARY way to understand pages.' It distinguishes from sibling cloak_screenshot by stating it's 'FASTER, CHEAPER, and MORE RELIABLE' and should be 'Always prefer this over cloak_screenshot for deciding what to click.' The description provides specific verb+resource differentiation.

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

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

The description provides explicit usage guidance: 'Call this BEFORE interacting with a page' and 'Always prefer this over cloak_screenshot for deciding what to click.' It clearly distinguishes when to use this tool versus the cloak_screenshot alternative and provides context about when to use full=True vs full=False modes.

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 and does well by disclosing key behavioral traits: it clears the field by default, can press Enter when submit=True, and returns an updated snapshot. It covers mutation behavior, default actions, and output format, though it doesn't mention error conditions or permission requirements.

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

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

The description is perfectly structured and front-loaded: the first sentence states the core purpose, followed by behavioral details, then a well-organized Args section. Every sentence earns its place with zero waste, making it easy to scan and understand.

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 complexity (5 parameters, mutation behavior), no annotations, and the presence of an output schema (which handles return values), the description is complete enough. It covers purpose, usage context, behavioral details, and parameter semantics comprehensively, leaving no significant gaps for agent 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?

With 0% schema description coverage, the description fully compensates by explaining all 5 parameters in the Args section: page_id (target page ID), ref (ref ID from snapshot with examples), text (text to type), clear (clear field before typing with default), and submit (press Enter after typing with default). It adds essential meaning beyond the bare 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 specific action ('Type text into an input'), identifies the target resource ('by its [@eN] ref ID from cloak_snapshot'), and distinguishes it from siblings like cloak_click or cloak_press_key by focusing on text input functionality. It provides a complete verb+resource+scope statement.

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 about when to use this tool ('Type text into an input by its [@eN] ref ID from cloak_snapshot'), implying it should be used after obtaining a snapshot. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools for similar actions.

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 key behavioral traits: the tool waits for specific conditions (DOM mutations cease, network idle), has a timeout mechanism, and returns status information (whether settled and mutation count). It doesn't mention error handling or performance impacts, but covers core behavior adequately.

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 efficiently structured: first sentence states purpose, second provides usage guidelines, third explains return values, and the Args section clearly documents parameters. Every sentence adds value with zero 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 moderate complexity (waiting for page stability), no annotations, and an output schema (implied by 'Returns whether...'), the description is complete. It covers purpose, usage, parameters, and return behavior without needing to detail 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 description coverage is 0%, so the description must compensate. It fully explains both parameters: page_id ('Target page ID') and timeout_ms ('Max wait time in milliseconds (default: 5000)'), adding crucial semantic context beyond the schema's basic types and titles.

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 with specific verbs ('Wait for the page to settle') and defines the settling criteria ('no DOM mutations + network idle'). It distinguishes itself from siblings like cloak_navigate or cloak_click by focusing on post-action waiting rather than navigation or interaction.

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 states when to use the tool: 'Use after actions that trigger dynamic content loading.' This provides clear context for application, distinguishing it from tools like cloak_read_page (for reading content) or cloak_screenshot (for capturing visuals).

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