octobrowser-mcp

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

With no annotations, the description carries the full burden, but it only reveals that the tool can click via selector or coordinates. It omits important behavioral traits such as whether the element must be visible, what happens when the selector is not found, whether navigation is waited for, or whether the click triggers page changes.

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, tight sentence that front-loads the action and immediately explains the two targeting modes. No filler or redundant details.

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

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

The core targeting modes are covered, but the description leaves ambiguity around what happens if both selector and coordinates are supplied, which is a realistic invocation concern. It also does not address error behavior or element visibility requirements. The existence of an output schema helps, but for a 5-parameter tool with no annotations the context is only minimally complete.

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

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

Schema description coverage is 100%, setting a baseline of 3. The description adds value by clarifying the relationship between the parameters: selector is the element-based targeting method, while x/y are the coordinate-based alternatives. This exceeds the schema's simple labels like 'X coordinate' and 'CSS selector of the element (optional)'.

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

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

The description states a specific verb 'click' with two clear target modes: CSS selector or x/y coordinates. This makes it immediately distinguishable from sibling tools like browser_hover, browser_type, and browser_select.

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

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

There is no guidance on when to use browser_click versus alternatives, nor when to choose coordinate-based clicking over selector-based clicking. The 'or' implies two modes but gives no preconditions, exclusions, or comparison with related browser tools.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does not mention that closing destroys the tab/page, may lose unsaved state, or how the browser chooses the next tab afterward. For a destructive operation, this is a meaningful 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 one short sentence with no filler. It is front-loaded and every word contributes to understanding the operation.

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

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

For a zero-parameter tool, the core action is fully specified and an output schema exists to describe return values. However, the lack of behavioral context about side effects and irreversibility, combined with no explicit usage guidance, prevents a higher 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 tool has zero parameters and schema description coverage is 100%, so there is no parameter documentation burden. The baseline score of 4 applies.

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

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

The description states a specific verb ('Close') and a specific resource ('the current tab'), making the operation unambiguous. Among the sibling tools it is clearly the tab-closing operation, distinct from browser_new_tab, browser_switch_tab, and browser_list_tabs.

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

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

The phrase 'current tab' implies the tool should be used when the agent wants to close the active tab. However, there is no explicit guidance about when to use it versus alternatives, such as switching to a different tab first to close a non-current tab.

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

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

With no annotations, the description clearly discloses the core side effect: establishing a CDP connection to an already-running profile, not starting one. It also communicates the required precondition. It does not detail connection lifecycle/cleanup, but for a simple connect operation this 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?

Two short sentences, with the essential operation first and the crucial sequencing second. No filler or repetition of the schema field.

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

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

For a single-parameter, low-complexity tool with an output schema, the description is largely sufficient: it states what is connected, via what protocol, and when to call it. It could add a note about calling browser_disconnect when done, but the sibling tool list makes that inferable.

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%; ws_endpoint is already documented as 'CDP WebSocket endpoint (from octo_start_profile)'. The tool description reinforces the origin of the endpoint but does not add substantial meaning beyond the schema, so the baseline of 3 applies.

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

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

Description uses a specific verb+object: 'Connect to a running Octo Browser profile over CDP', making the action and protocol explicit. The phrase 'running ... profile' plus 'Call after octo_start_profile' clearly distinguishes it from launching a profile (octo_start_profile) and from browser_disconnect.

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

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

It gives an explicit prerequisite and timing cue: 'Call after octo_start_profile.' This tells an agent when in the workflow to invoke it. It does not explicitly name alternatives/exclusions (e.g., browser_disconnect for teardown), so it falls short of a full 5.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It discloses a key behavioral boundary: the browser connection is dropped but the Octo profile remains running. It does not detail every side effect, but for a zero-parameter disconnect action this is sufficient.

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

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

The description is a single, front-loaded sentence that communicates both the primary action and a key exception. Every word adds value, and there is no redundant or filler content.

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

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

For a zero-parameter tool with an output schema present, the description is largely complete. It names the action and clarifies what it does not do. It could mention the relationship to browser_connect directly, but the current text is enough for correct invocation in most contexts.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain any parameters, and the schema already confirms there are none.

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: disconnect from the browser. It also distinguishes itself from sibling tools like octo_stop_profile by explicitly noting it does not stop the Octo profile. The verb-resource relationship is unambiguous.

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

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

The parenthetical 'does not stop the Octo profile' provides useful context for when to use this tool versus stopping a profile. However, it does not explicitly name alternatives such as octo_stop_profile or browser_connect, so the guidance is slightly implied rather than fully 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 the full burden of behavioral disclosure. It mentions returning a result but does not disclose that arbitrary JavaScript may have side effects on the page, how errors are handled, whether the script runs in the page's main world, or whether asynchronous results are supported.

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, direct sentence with no filler or redundant phrasing. It front-loads the core action and result without unnecessary elaboration, making it easy for an agent to parse 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?

For a one-parameter tool with an output schema, the description is minimally viable, but it leaves meaningful gaps. It omits guidance about side effects, execution context, error behavior, and when this tool is the appropriate choice among the many browser siblings, making it only partially complete.

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

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

The schema already fully documents the single 'script' parameter with 100% coverage, so the baseline is 3. The description adds minimal parameter-level meaning beyond saying the script runs 'on the page,' which mostly reinforces the schema rather than explaining syntax, expected format, or execution context.

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

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

The description clearly states a specific verb ('Run JavaScript') and resource ('the page'), and indicates that a result is returned. This distinguishes it from sibling browser tools like navigation, clicking, and text extraction, which perform more targeted 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 the tool is for executing JavaScript in the current page and obtaining a result, which conveys its basic use case. However, it provides no explicit guidance on when to prefer it over other browser tools, nor does it mention any exclusions or prerequisites such as requiring an active page.

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 correctly signals a read-only operation ('Get'), but it doesn't disclose behavior for edge cases like a missing attribute or nonexistent element, nor whether it waits for the element to appear. For a simple getter, this is adequate but not rich.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the 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 two-parameter read tool with full schema coverage and an output schema, the description covers the essential purpose and result. It lacks usage comparisons and edge-case behavior, but those are already penalized in other dimensions.

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

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

Schema coverage is 100%, so the schema already documents selector and attribute. The description adds no extra meaning beyond naming the operation, which matches the baseline of 3.

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

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

The description clearly specifies a verb ('Get'), a resource ('attribute value'), and a target ('element'), which distinguishes it from sibling getters like browser_get_text and browser_get_html. It could be a 5 if it explicitly named alternatives, but it doesn't.

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

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

There is no guidance on when to choose this over related tools such as browser_get_text, browser_get_html, or browser_evaluate. The intended context is only implied by the name and description.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose that the tool returns HTML for either the full page or an individual element, and the optional selector is implied. However, it says nothing about return formatting, error behavior, or the distinction between outerHTML and innerHTML beyond what the schema already documents, so coverage is only partial.

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 entire description is a single nine-word sentence with no filler. It front-loads the action and resource, and every word adds 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 read-only getter, the description plus the fully documented schema provide enough to invoke the tool correctly. An output schema exists, so return values are presumably documented elsewhere. The only minor gap is that the description doesn't explicitly state the behavior when no selector is provided, although 'page' implies it.

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

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

Schema description coverage is 100%, so the schema already fully documents the 'outer' and 'selector' parameters, including defaults and semantics. The description adds no extra parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') with a clear resource ('the HTML') and a scope ('the page or an element'). This differentiates it from sibling tools like browser_get_text, browser_get_attribute, and browser_get_url, so an agent can select it without inspecting the schema.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_get_text or browser_evaluate. The description only states what it does; it does not mention exclusions, prerequisites, or selection criteria. Usage must be inferred entirely from the name and purpose.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It accurately indicates a read operation, but it does not mention what happens when the selector matches no element, whether hidden elements are included, whether it waits for the element, or whether the text is trimmed. These are significant undocumented behaviors for a web automation 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 a single, front-loaded sentence that conveys the core operation without wasted words. It is appropriately concise for a simple getter tool.

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

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

This is a simple tool with one well-documented parameter and an output schema present, so the description need not explain return values. It is mostly complete for basic usage, though added context about selector behavior or alternative tools would make it stronger. It is not severely incomplete given the tool's low complexity.

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

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

Schema description coverage is 100% for the single 'selector' parameter, which is already fully described as a CSS selector. The tool description adds no additional meaning about parameter format, semantics, or edge cases, so the baseline score of 3 is appropriate.

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

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

The description states a clear verb ('Get') and resource ('text content of an element'). It is distinguishable from siblings like browser_get_html and browser_get_attribute by specifying 'text content' rather than HTML or attributes. However, it does not explicitly differentiate itself from those 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?

There is no guidance about when to use this tool versus alternatives such as browser_get_html, browser_get_attribute, or browser_evaluate. The intended context is only implied by the name and description, with no explicit exclusions or alternative recommendations.

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

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

With no annotations, the description carries the full burden. The verb 'Get' clearly indicates a read-only operation with no side effects. However, it does not disclose what happens if no page is loaded, whether the URL refers to the active tab, or whether a browser connection is required. These omissions are notable but not severe for a simple getter.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. It is appropriately sized for a zero-parameter tool and communicates the core action clearly.

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

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

For a zero-parameter getter with an output schema present, the description is mostly complete. It could slightly clarify that 'current page' means the active tab in a multi-tab browser session, but the simplicity of the tool and the presence of an output schema reduce the need for additional detail.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly focuses on the operation rather than parameter details, since there are no parameters to describe. No additional parameter semantics are needed.

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

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

The description uses a specific verb ('Get') and a clear resource ('the current page URL'), which is distinct from sibling getters like browser_get_text, browser_get_html, and browser_get_attribute. An agent immediately understands this tool's unique role among the browser_* tools.

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

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

The description implies the usage: call this when you need the current page URL. However, it does not explicitly state when to prefer this over alternatives or provide any exclusion criteria. Since there is no sibling specifically for URLs, the guidance is adequate but implicit.

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 carries the full burden of behavioral disclosure. It states the core navigation action but does not disclose what happens when history is empty, whether a browser session must already be connected, whether it operates on the active tab, or whether it waits for the page to load.

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

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

A single short sentence states the action with no filler. It is front-loaded and appropriately sized for a parameterless tool.

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

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

For a zero-parameter tool with an output schema, the main action is covered, but the description omits operational details such as prerequisites and empty-history behavior. These gaps prevent it from being fully complete despite the low complexity.

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

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

The tool has zero parameters, so the schema already exhaustively covers all inputs; the description does not need to explain parameter details. Baseline of 4 applies.

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

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

The description names a specific action ('Go back') and a clear resource ('browser history'), leaving no doubt about what the tool does. It also implicitly distinguishes itself from browser_go_forward and browser_navigate.

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

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

The statement 'Go back in browser history' gives clear context for when the tool applies: whenever backward navigation in the history stack is needed. It does not name alternatives or exclusions explicitly, but for a zero-parameter action the intended use is obvious.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only restates the action and does not explain behavior when there is no forward history, whether navigation is awaited, or what happens to the current 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 a single, clear sentence with no wasted words. It is appropriately sized for a trivial no-argument tool and is immediately understandable.

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

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

The tool is simple, has no parameters, and an output schema is present, so the descriptive burden is low. The description covers the core function, though it could usefully note behavior at the end of forward history.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly avoids inventing parameters and there is no parameter semantics gap to fill.

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

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

The description states a specific action on a specific resource: moving forward in browser history. It clearly differentiates from the sibling browser_go_back by direction, though it does not mention any other navigation alternative.

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 about when to use this tool versus browser_go_back, browser_navigate, or other navigation tools. The intended usage is implied by the name and description, but there is no explicit context or 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 are provided, so the description carries the burden of explaining behavior. It clearly states the action of hovering, which is transparent enough for this simple tool, but it does not disclose edge-case behaviors such as whether the element must be visible or whether a wait is required.

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

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

A single sentence with no filler. The core action is front-loaded and the parenthetical adds practical context without bloat.

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

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

For a simple one-parameter hover action, the description is adequately complete. The output schema exists, so return values do not need to be explained. It could be slightly richer with caveats about element visibility or interaction timing, but those are not required for basic usage.

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

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

Schema description coverage is 100%, so the parameter 'selector' is fully documented in the schema as a CSS selector. The description adds no additional parameter-level semantics, which is acceptable given the schema already covers it.

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

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

States a specific verb ('hover') and resource ('an element'), and clarifies the purpose with 'useful for dropdowns and tooltips.' This makes it immediately distinguishable from sibling actions like browser_click or browser_type.

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

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

The description gives clear context for when hover is appropriate: dropdowns and tooltips. It does not explicitly mention alternatives or when not to use it, but the use-case framing is sufficient for a simple interaction.

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

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

With no annotations, the description carries the behavioral transparency burden. The verb 'List' makes the read-only, non-mutating nature clear, and the description specifies exactly what data is returned. It does not disclose potential error cases, but none are critical for such a simple read 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?

A single, focused sentence states the action, scope, and output fields with no wasted words. The description is appropriately concise for a tool with no 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?

The tool is simple, has no parameters, and has an output schema, so the description only needs to state the tool's purpose and returned data fields. It fully covers what an agent needs to know to invoke and interpret the tool correctly.

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

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

The tool has zero parameters, so parameter semantics are trivially satisfied. The schema coverage is complete, and the description does not need to compensate for any missing parameter documentation.

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') with a clear resource ('open tabs') and names the output fields (title, URL, active flag). This clearly distinguishes the tool from tab-manipulation siblings like browser_switch_tab, browser_new_tab, and browser_close_tab.

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

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

The usage is implied: listing tabs is a natural precursor to switching or closing them, but the description does not explicitly say when to use this tool versus alternatives. There are no exclusions or explicit alternative routing.

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 carries the full burden of explaining behavior. It only restates that the tool navigates; it does not disclose whether an active browser connection is required, what wait behavior is used, whether a new tab is opened, or what happens on failure.

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

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

The description is a single efficient sentence with no wasted words, and the main verb is front-loaded. It borders on under-specification, so it does not earn a 5, but it is structurally very 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 navigation tool with full schema coverage and an output schema, the description is minimally viable: the required parameter and wait strategy are documented. However, it still omits the browser-connection prerequisite and does not help an agent choose among the many browser sibling tools.

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

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

Schema description coverage is 100%, so the parameters are already documented sufficiently for the baseline. The description adds no extra meaning about the URL or wait strategy, and the enum values for wait_until are not explained, but the schema already covers the basic semantics.

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

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

The description clearly states a specific action ('Navigate') and its target resource ('a URL'), so the basic purpose is unambiguous. It does not explicitly distinguish itself from sibling navigation tools like browser_go_back, browser_reload, or browser_get_url, which keeps it from a 5.

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

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

The description provides no information about when to use this tool versus alternatives such as browser_go_back, browser_reload, or browser_connect. There is no mention of prerequisites, exclusions, or contextual cues for choosing navigation over other browser 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, the description carries the full burden of disclosing behavior. It states the core action and the optional URL navigation, but it does not mention whether the new tab becomes active/focused or what happens when URL is omitted. This is a meaningful but minor gap for a simple browser 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 a single compact sentence that front-loads the primary action ('Open a new tab') and then adds the optional behavior. Every word earns its place, with no redundancy or filler.

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

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

For a simple one-parameter tool with an output schema, the description covers the core invocation and the optional argument. It is sufficiently complete to select and call the tool, though slightly more context about tab-activation behavior would make it fully self-contained.

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

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

Schema description coverage is 100%, so the schema already documents the url parameter as 'URL to open (optional)'. The tool description adds no substantial meaning beyond that, so the baseline score of 3 is appropriate.

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

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

The description names a specific action ('Open a new tab') and a clear resource, with the navigation behavior as optional. It is immediately distinguishable from sibling tools like browser_navigate, browser_switch_tab, and browser_close_tab because it centers on creating a new tab.

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

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

The description gives clear context for what the tool does, but it does not explicitly say when to use it instead of browser_navigate or browser_switch_tab, nor does it mention any exclusion criteria. Usage guidance is implied by the tool name and the phrase 'new tab' but is not made 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 carries the full burden. It states the action and key examples, but does not disclose where the key event is delivered (focused element), whether it can trigger navigation or form submission, or whether modifier combinations are supported.

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

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

The description is a single concise sentence with the key action front-loaded and illustrative examples attached. Every element earns its place with no repetition or filler.

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

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

For a one-parameter tool with full schema coverage and an output schema, the invocation details are mostly present. However, the lack of usage guidance and behavioral context about focus and side effects leaves the description barely adequate for an agent to make fully informed call decisions.

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 already documents the key parameter with examples, and schema description coverage is 100%. The description's examples mostly overlap with the schema and add little new semantic meaning, so the baseline of 3 is appropriate.

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

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

The description names a specific verb ('Press') and resource ('a keyboard key'), with concrete examples that make the action unmistakable. It is clearly distinct from siblings like browser_click, browser_type, and browser_scroll, even without explicit cross-references.

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

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

There is no guidance about when to use this tool versus alternatives such as browser_type, browser_select, or browser_click. The context is implied by the name, but no exclusions, prerequisites, or preferred use cases are 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 the full burden of behavioral disclosure. It only says the tool returns metadata and does not explain whether it is read-only, what happens when no elements match, whether it waits for elements, or whether it returns an empty list or throws an error.

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 one concise sentence with no wasted words and the action is front-loaded. It could include more behavioral detail, but as written it is efficient and appropriately sized for a tool with a single parameter.

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

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

The tool has one parameter and an output schema, so the basic operation is adequately captured. However, the term 'metadata' is ambiguous, and there is no mention of behavior when the selector matches no elements or whether the page must already be loaded, leaving meaningful 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 coverage is 100% and the only parameter is already described as 'CSS selector'. The description adds no further meaning beyond that, so the baseline of 3 applies because the schema already documents the parameter adequately.

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

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

The description uses a specific verb ('Find all elements') and names the resource (elements matching a selector), which clearly conveys the core operation. It distinguishes this from siblings like browser_get_text or browser_get_html, though 'return their metadata' is somewhat vague about what metadata means.

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 offered about when to use this tool versus alternatives such as browser_wait_for_selector, browser_get_attribute, or browser_evaluate. The description implies use for querying multiple elements but does not state when it should or should not be chosen.

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

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

The description states the core effect plainly: the current page is reloaded. However, with no annotations to rely on, it does not disclose any additional behavioral traits such as whether the active tab is targeted, whether page state is lost, or whether the tool waits for the reload to finish. The simplicity of the action keeps this from being a lower score, but there is room for more transparency.

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

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

The description is a single, complete sentence with no unnecessary words. It is front-loaded and immediately comprehensible. No filler or redundant information is present.

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

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

Given that the tool has no parameters and an output schema is present, the description is nearly sufficient. The only missing context is guidance on when reloading is appropriate and whether there are side effects on the page state. Still, for a simple command like this, the definition is close to fully adequate.

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

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

The tool has zero parameters, so the description does not need to explain parameter behavior. The schema coverage is effectively 100% because there are no properties to document. This is a reasonable baseline score for a parameterless tool.

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

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

The description clearly states a specific action ('reload') on a specific resource ('the current page'), which aligns directly with the tool name. It is understandable without needing to inspect the schema. However, it does not explicitly distinguish itself from related navigation tools like browser_navigate or browser_go_forward, though the meaning is still unambiguous.

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

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

The description provides no guidance about when to use this tool versus alternatives such as browser_navigate, browser_go_back, or browser_go_forward. It also omits context like whether the page needs to be loaded first or what happens if the browser is not connected. There is no stated best use case, so agents must infer the intended usage from the name alone.

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

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

With no annotations, the description carries the full burden. It discloses the core behavior (screenshot of page/element) and the PNG output, but does not explain how the PNG is returned (e.g., base64, binary, path), behavior when an element is not found, or whether it waits for rendering to complete. This is a notable gap for an unannotated tool.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the PNG return type adds valuable information without redundancy. Every word earns its place.

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

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

For a simple two-parameter tool, the description covers the basic purpose and output, but lacks important context such as output encoding, error handling for invalid selectors, and interaction between full_page and selector. Given there is no output schema or annotations, these details would help an agent invoke and process the result correctly.

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

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

Schema description coverage is 100%, so the schema already explains both parameters well. The description adds only the high-level notion of 'page or element', which mirrors the schema's selector description and does not provide additional detail about parameter interactions or edge cases.

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 a specific action ('Take a screenshot') and the resource ('page or of a single element'), distinguishing it from sibling browser tools that perform navigation, clicking, or evaluation. It also specifies the return format (PNG), making the tool's purpose unambiguous.

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

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

The description makes it clear the tool is used for capturing either the whole page or a specific element, with the selector parameter determining which. There are no competing screenshot tools among the siblings, so no alternative routing is needed, but explicit when-to-use/when-not-to-use guidance 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the core action. It does not describe what happens when the selector is invalid, whether the scroll is animated, or what is returned, though the tool is simple and non-destructive.

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

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

The description is a single sentence with no filler. It front-loads the action and immediately differentiates the two main usage modes, making it easy for an agent to parse 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 low complexity, fully documented parameters, and presence of an output schema, the description is mostly complete. It only lacks minor edge-case behavior like error handling for invalid selectors, but that is not essential for basic 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 100%, so the input schema already documents 'amount', 'selector', and 'direction'. The description adds no additional semantic detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Scroll') and the resource (page or a specific element via selector), clearly identifying the tool's function. Among the sibling browser_* tools, this uniquely describes a scrolling action, so an agent can distinguish it without opening the schema.

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

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

The description implies when to use the tool: for scrolling the page or a specific element when a selector is provided. However, it does not explicitly mention alternatives or exclusion cases, such as using browser_evaluate for programmatic scroll or noting that a selector is required for element scrolling.

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 only states the basic action and does not mention whether the selection triggers change/input events, whether the element must be visible or enabled, or how 'value' is matched against the option (value attribute vs. label).

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, front-loaded sentence with no filler or redundancy. For a simple tool with two well-named parameters, this level of conciseness is appropriate.

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

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

The tool is simple, has full schema coverage, and an output schema exists, so the description is minimally viable for an agent to invoke it. However, it lacks behavioral context such as event behavior and value-matching semantics, and the absence of annotations leaves some operational details unspecified.

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

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

The input schema documents both 'selector' and 'value' with 100% coverage, so the schema already defines parameter meaning. The description adds no additional parameter context beyond the schema, making the baseline 3 appropriate.

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

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

The description uses a specific verb ('Select') and a clear resource ('an option in a <select> dropdown'), which unambiguously identifies the operation. It also implicitly distinguishes this tool from sibling tools like browser_click and browser_type because it targets the select element's option-selection behavior.

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

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

There is no guidance on when to use this tool versus alternatives, and no exclusion or prerequisite information is provided. The intended usage must be inferred entirely from the tool name and the one-line description.

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 responsibility for behavioral disclosure, but it only states the action. It does not mention side effects, behavior on invalid index, or whether it activates the tab for subsequent commands.

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

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

The description is a single concise sentence with no redundant words, and it front-loads the core action. It could be slightly more informative, but it is appropriately sized for such a simple operation.

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

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

For a one-parameter tool with an output schema and no annotations, the description is minimally adequate. However, it lacks context about how to obtain a valid tab index (e.g., via browser_list_tabs) and what happens if the index is out of range, leaving some 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?

The schema fully documents the single parameter 'index' with type, minimum, and zero-based description. The description only replicates 'by index' and adds no additional semantic meaning, so the baseline score applies.

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

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

The description uses a specific verb 'Switch' with a clear resource 'tab' and the method 'by index'. It clearly conveys what the tool does and is distinct from related operations like browser_navigate or browser_list_tabs, though it does not explicitly contrast itself with 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?

No guidance is provided on when to use this tool versus alternatives, such as browser_list_tabs for obtaining indices or browser_navigate for changing pages. The usage context is entirely implied.

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 carry behavioral disclosure. It does disclose the two behavioral modes—instant fill with selector vs key-by-key typing into the focused element—which is valuable. But it leaves important behavior unclear, such as whether typing replaces existing text, appends, or fires events, so it only partially covers the expected transparency burden.

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 short sentences, front-loaded with the core action and followed by precise mode details. There is no redundant language or filler; every phrase contributes to 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?

For a three-parameter typing tool, the description covers both invocation modes and benefits from an existing output schema. However, it omits common behavioral clarifications like text replacement vs appending and support for special keys, leaving moderate ambiguity for an agent deciding how to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the behavioral consequence of the selector parameter ('filled instantly' vs 'typed key by key') and clarifying that omitting the selector targets the focused element, which is not explicitly in the schema property description. This supplements the structured parameter docs.

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

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

The description opens with 'Type text', a specific verb and object, and clarifies two modes: with a selector the value is filled instantly, without it text is typed key by key into the focused element. This gives clear functional meaning beyond the tool name, though it does not explicitly distinguish from sibling tools like browser_press_key.

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

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

Usage context is implied: use this tool to type text, with an optional selector or into the focused element. However, there is no explicit guidance about when to prefer this over alternatives such as browser_press_key or browser_click, and no exclusions or fallback conditions are 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 the full burden of behavioral disclosure. It does not explain whether the tool polls, throws on timeout, returns immediately if the state is already satisfied, or has any side effects. The description only restates the basic waiting concept without operational detail.

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

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

The description is a single sentence with no filler and a front-loaded verb. It is appropriately sized for a simple wait operation and contains no redundant or misleading content.

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

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

The full input schema and presence of an output schema cover parameter and return semantics, so the description only needs to add operational context. It provides the core purpose but lacks any usage scenario or behavioral detail, making it minimally complete rather than fully robust.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add extra meaning to the parameters, but the schema already documents selector as a CSS selector, state with its enum values, and timeout in milliseconds. No compensation is needed.

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

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

The description states a specific verb ('Wait') and a resource ('an element') with a condition ('reach a given state'). It is clearly distinct from sibling browser tools, none of which describe waiting for an element state. However, it does not explicitly mention the browser context, relying on the tool 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 gives no guidance on when to use this tool versus alternatives, such as waiting before clicking or typing after navigation, or how to handle timeout situations. Usage must be inferred entirely from the tool name and general browser automation conventions.

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 behavioral disclosure burden. It reveals a non-obvious and important side effect: extensions in use by a running profile come back once that profile stops. This is meaningful transparency, though it doesn't mention permissions, irreversibility, or failure modes.

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

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

Two concise sentences, with the primary purpose front-loaded before the important behavioral caveat. No filler or redundant phrasing.

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 single-parameter delete operation with an output schema present, the description covers the core action and the critical lifecycle caveat. It lacks explicit notes on permissions or broader operational context, but the essential information for calling correctly is provided.

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

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

Schema coverage is 100% and the schema already describes the 'uuids' parameter with an example format ('abc123@2.0.12'). The tool description only repeats 'by UUID' and adds no new semantic nuance beyond the schema.

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

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

The description clearly states the action ('Delete'), the resource ('team extensions'), and the method ('by UUID'). It unambiguously distinguishes this from sibling read/list tools like octo_get_extensions, and the scope 'team extensions' adds precision.

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

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

The description does not explicitly state when to use this tool vs alternatives or exclude any conditions. However, the note about extensions returning after a running profile stops implies a key consideration for use, so usage context is partially conveyed rather than fully 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully discloses the auth requirement (OCTO_API_TOKEN) and the prefix-matching behavior. However, it does not describe behavior on no matches, multiple matches, or whether exact_match changes the result semantics beyond what the schema already states.

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 short sentences plus an auth note, with the core action and key matching behavior front-loaded. Every sentence earns its place; there is no filler, repetition of the tool name, or redundant schema restating.

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

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

For a simple two-parameter lookup with an output schema, the description plus schema covers the basics: what it does, how matching works, and that a token is required. Still, with no annotations and several sibling profile-related tools, it lacks explicit selection guidance and edge-case behavior, so it is not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds real semantic value by explaining that the API matches from the beginning of the title, which clarifies how the 'name' parameter behaves. It introduces a slight name-versus-title wording inconsistency, but overall it enhances parameter understanding.

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

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

The description states a specific action ('Find a profile by title') and clarifies the matching rule ('matches from the beginning of the title'). It is not a tautology and gives enough resource/scope detail. It does not explicitly distinguish itself from sibling lookup tools like octo_get_profile or octo_search_profiles, so it misses the top score.

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 prefix-matching note implies this tool is appropriate when searching by the beginning of a profile title, but there is no explicit when-to-use/when-not-to-use guidance. Alternatives such as octo_get_profile or octo_search_profiles are never mentioned. The usage context is implied rather than clearly routed.

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

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

No annotations are provided, so the description carries the behavioral burden. 'List' clearly indicates a non-mutating read operation, which is useful, but the description does not disclose additional behavioral aspects such as team scope semantics, empty-result behavior, or whether any authorization is required.

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

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

The description is a single, front-loaded sentence that conveys the operation, the resource, and the relevant output fields with no filler or 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 zero-parameter read-only listing tool with an output schema available, the description is sufficient. It names the resource, the intended scope ('team's'), and the key returned fields, so an agent has enough context to invoke it correctly.

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

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

There are zero parameters, so parameter semantics are trivially complete. The description adds value by specifying the output fields (name, version, UUID), and schema coverage is 100% because there are no properties to document.

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

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

The description states a specific verb ('List'), a specific resource ('the team's browser extensions'), and the data returned ('name, version and UUID'). This clearly distinguishes it from sibling tools like octo_delete_extensions, which performs a mutation.

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

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

The description implies this tool is for retrieving an inventory of browser extensions, but it does not explicitly state when to use it versus alternatives or when not to use it. The context is reasonably clear, but there is no explicit routing guidance relative to 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 behavioral burden. 'Get' clearly signals a read-only retrieval and the field list states what is returned; no destructive or state-changing behavior is suggested. It does not discuss error conditions or permissions, but for a simple getter this is adequate.

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

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

One sentence with the verb and resource front-loaded, followed by a compact field list. No filler or redundant clauses.

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

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

The tool has a single required parameter fully described by the schema, and an output schema exists. The description plus schema is sufficient for an agent to call this tool correctly, and there are no nested objects or complex edge cases requiring extra context.

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

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

The input schema already documents uuid as 'Profile UUID' with 100% coverage. The description's 'by UUID' restates the lookup role but adds no new constraint or format. Therefore the description adds minimal meaning beyond the schema.

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

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

The description names a specific verb ('Get'), the resource ('full profile data'), and the lookup key (UUID), and enumerates the data included. This distinguishes it from sibling getters like octo_get_extensions, octo_get_tags, and octo_get_proxies, as well as from lookup-by-name tools.

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

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

The description implies it should be used when a UUID is already available and the caller wants the entire profile. It does not explicitly mention alternatives such as octo_find_profile_by_name or octo_search_profiles for cases where the UUID is unknown, so guidance is only implicit.

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

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

With no annotations, the description carries the full burden. The verb 'List' clearly indicates a read-only operation, and it states the exact output fields. It does not mention edge cases such as empty results or authentication, but for a simple list operation this is acceptable and not misleading.

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

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

One concise sentence with no filler. The action and object are front-loaded, and the field list follows naturally, making it easy to parse 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?

For a tool with no parameters and an output schema already covering return values, the description is complete. It clearly states what the tool does and the key output fields, so an agent has sufficient information to invoke it correctly.

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

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

The tool takes zero parameters, so the parameter semantics are trivially satisfied. The description adds value by specifying output fields rather than parameter details, matching the baseline for no-parameter tools.

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 uses a specific verb 'List', names the resource 'saved proxies', and enumerates the returned fields: type, host, port, and UUID. No sibling tool targets proxies, so it is clearly distinguished from the other listed tools.

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

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

The description makes the usage context clear: this tool is for viewing all saved proxies. There are no alternative proxy tools among siblings to compare against, so explicit exclusions are unnecessary. It falls short of 5 because it does not explicitly state when not to use the tool.

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

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

With no annotations provided, the description carries the full burden. 'List all profile tags' clearly conveys a non-mutating read operation with no side effects, and the field list gives concrete behavioral expectations without overclaiming.

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

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

The description is a single, front-loaded sentence with no filler. Every word adds meaning, and it is immediately scannable by an agent.

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

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

For a zero-parameter, simple listing tool with an output schema, the description is complete. It names the resource, the scope ('all'), and the expected fields, leaving no critical ambiguity for an agent deciding to call it.

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

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

The tool has zero parameters and the schema fully documents that, so the description needs no parameter guidance. The 0-parameter baseline applies here, and the description adds no unnecessary parameter-related noise.

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 a specific resource ('all profile tags'), and enumerates the returned fields (name, color, UUID). It clearly differentiates this tool from the many sibling tools that deal with profiles, extensions, proxies, and browser operations.

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

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

The description makes the tool's use case clear: retrieving all profile tags. It does not explicitly state when not to use it, but there is no competing tag-listing sibling, so the context alone sufficiently guides 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 behavioral burden. 'Check' and 'verify' convey that this is a non-mutating reachability probe, which is the essential trait. However, it does not disclose what happens when the API is unreachable, whether failures surface as errors or status payloads, or explicitly confirm zero side effects. The output schema can cover return shape, but failure semantics are left implicit.

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

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

Two short sentences with zero filler. The verb and resource are front-loaded, and 'Call this first' earns its place as actionable guidance. Every word contributes.

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

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

For a zero-parameter, low-complexity health check with an output schema to document return values, the description is complete: it states what the tool does and when to call it. The sibling list confirms this is the only health probe, so there is no routing ambiguity. Nothing an agent needs to call it correctly is missing.

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

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

The input schema has zero parameters, so the baseline is 4 — there is nothing for the description to add or clarify. Any parameter detail would be noise, and the description correctly avoids inventing any.

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

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

States a specific verb ('Check') and resource ('Octo Browser API') with a clear intent ('verify the app is running'). It is unambiguous against the sibling list, which contains only profile-management and browser-automation tools — nothing else targets API reachability.

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?

'Call this first to verify the app is running' is explicit timing guidance that tells the agent when to invoke it, namely as a pre-flight check before other operations. It does not name alternatives or when-not conditions, but for a health check there are no natural alternatives among the 35+ siblings, so the timing instruction is the material guidance and it is present.

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

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

With no annotations, the description carries the burden. The verb 'List' transparently indicates a read-only operation, and specifying the output fields adds useful context. It does not explicitly say 'no side effects', but nothing implies mutation or hidden 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?

A single sentence that front-loads the operation and includes only high-value details: scope ('currently running'), location ('this machine'), and return fields. No filler.

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

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

Zero parameters and an available output schema lower the burden on the description. The description supplies the necessary behavioral detail for an agent to invoke this tool correctly and interpret the result.

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

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

The tool has zero parameters and 100% schema coverage, so there is nothing for the description to add. Baseline 4 applies.

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

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

The description uses a specific verb 'List' with a precise resource 'profiles currently running on this machine' and enumerates returned fields (UUID, title, ws_endpoint). This clearly distinguishes it from siblings like octo_search_profiles and octo_get_profile by scoping to running profiles.

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

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

The phrase 'currently running on this machine' provides clear context for when this tool is appropriate. It does not explicitly name alternatives or exclusion conditions, so it stops short of the top score.

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

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

No annotations exist, so the description carries the burden. It does disclose the token requirement and the AND semantics for tags, but much of this repeats the parameter schema, and it does not state the relationship between search and tags when both are supplied. It also does not explicitly confirm the operation is read-only.

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 terse sentences with no filler; the main purpose leads, and the token requirement and tag behavior are compactly stated. Every sentence earns its place.

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

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

The schema covers all five parameters and an output schema exists, but the tool description leaves a key ambiguity: whether search and tags combine with AND or OR. It also does not mention how this search relates to the many listing and finding siblings, so an agent must infer the intended 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?

Schema coverage is 100%, so parameters are already documented in the input schema; the description adds no meaning beyond what the schema already provides for tags and title prefix. 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 names a specific operation ('Search profiles') and defines the search criteria ('by title prefix or tags'), which distinguishes it from list/find siblings. It is clear but does not explicitly contrast it with octo_list_profiles or octo_find_profile_by_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?

It provides a prerequisite ('Requires OCTO_API_TOKEN') and tag combination rule, but gives no guidance on when to choose this tool over octo_list_profiles or octo_find_profile_by_name. Without explicit alternatives or exclusions, an agent must infer usage from the tool name.

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

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

With no annotations, the description carries the burden and does disclose important behavior: the profile is temporary, removed once stopped, and starts faster than a regular profile. It does not discuss failure modes or cleanup details, but the core lifecycle is transparent.

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

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

Two sentences with no filler; the key differentiator and intended use are front-loaded. Every sentence earns its place.

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

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

For a 2-parameter tool with an output schema and no required parameters, the description covers purpose, lifecycle, and typical use. It could be slightly more explicit about alternatives, but nothing essential is missing.

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

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

Schema descriptions cover both parameters completely, including the os enum/default and headless boolean/default. The tool description adds no parameter-specific meaning, so the baseline 3 applies.

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

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

Description opens with a specific verb and resource: 'Create and start a one-time (temporary) profile.' It clearly differentiates from regular profiles by noting it is removed once stopped and starts faster, which distinguishes it from siblings like octo_start_profile and octo_start_profile_by_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 gives an explicit use case ('suits scraping') and contrasts with a regular profile's persistence/speed. It does not name sibling tools or state when not to use it, but the context is clear enough to guide 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?

With no annotations, the description carries the full burden. It discloses the main side effect (launching/starting a profile), the returned artifact (ws_endpoint), and an important behavioral trait (already-running profiles are reused). It doesn't describe failure modes or resource implications, but for a simple start action this is solid.

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 compact sentences with the primary purpose and return value front-loaded, followed by the key conditional behavior. Every sentence adds value and no filler is present.

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, fully described parameters, and the presence of an output schema, the description covers the necessary behavioral context. The idempotency note is especially useful and nothing critical is missing for an agent to call this tool correctly.

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

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

Schema description coverage is 100%, so all three parameters (uuid, headless, password) are already documented with meaningful schema descriptions. The tool description adds no additional parameter meaning, so the 100% schema coverage baseline of 3 applies.

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

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

The description states a specific action (start a profile), the key identifier (UUID), and the concrete return value (ws_endpoint for the CDP connection). It also distinguishes this tool from sibling octo_start_profile_by_name by scoping it to UUID-based lookup.

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

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

The phrase 'by UUID' clearly signals when this tool is appropriate versus name-based alternatives, and the idempotent 'already running' clause tells the agent it can safely reuse it. It does not explicitly say when to choose another tool or mention exclusions, so it misses the top score.

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

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

With no annotations, the description carries the full burden and does disclose a key prerequisite: 'Requires OCTO_API_TOKEN.' It also clearly identifies the state-changing behavior by saying the tool will 'start it.' It does not describe edge cases like an already-running or missing profile, but the core behavioral and authentication facts are present.

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 only two short sentences. The core purpose is front-loaded first, and the authentication requirement is stated with no wasted words or redundant schema repetition.

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

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

The description covers the essential what and auth need, and since an output schema exists, return values are already handled. The main gap is not explaining when to choose this over sibling tools such as octo_start_profile or octo_find_profile_by_name, which limits full context for tool 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 input schema provides 100% description coverage, including a helpful example for the name parameter, so the baseline applies. The tool description itself adds no parameter-level details beyond what the schema already gives.

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 a specific composite action: 'Find a profile by title and start it (find + start in one call).' The verb-resource pair is unambiguous, and the parenthetical distinguishes it from plain find or start tools.

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

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

The 'find + start in one call' phrasing signals that this tool consolidates two operations, which tells an agent when to use it. It does not explicitly name alternatives like octo_find_profile_by_name or octo_start_profile or give when-not-to-use conditions, so it falls just short of full routing 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 carries the behavioral disclosure burden. It states the core action and target, which is helpful, but it does not disclose potential side effects such as whether the browser process is terminated, what happens if the profile is not running, or any authentication/ownership requirements. The force parameter's graceful-stop nuance appears only in the schema, not in the tool description.

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, focused sentence with the action and object front-loaded. Every word contributes meaning, and there is no redundant or filler content. This is an appropriate size for a simple two-parameter tool.

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

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

For a simple tool with two well-documented parameters and an output schema, the description covers the essential invocation: what action to take, against which resource, and by which identifier. It could be more explicit about the relationship to browser_disconnect or behavior when the target is not running, but these are not critical for basic 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 100%, so the schema already documents both uuid and force. The description adds only 'by UUID', which re-affirms the required parameter without adding new semantic detail. It does not compensate with additional context, but with full schema coverage, 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 ('Stop'), identifies the exact resource ('running Octo Browser profile'), and specifies the identifier mechanism ('by UUID'). This clearly distinguishes it from sibling lifecycle tools like octo_start_profile and browser_disconnect 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 phrase 'Stop a running Octo Browser profile' provides clear context for when to use the tool: when a profile is running and should be terminated. It does not explicitly name alternatives or exclusions, but no competing stop tool exists among the siblings, so the usage context is sufficiently unambiguous.

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