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

With no annotations, the description carries the full burden and does well: it discloses execution order, fail-fast behavior ("se detiene en el primer error"), and that snapshot:true returns the final state. It omits what the error response looks like and whether partial results are returned or refs stay valid after earlier actions mutate the page.

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

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

Front-loaded with the core claim, then the example, then the execution semantics—dense and waste-free. The example is inline rather than a separate block, which reads slightly compressed but nothing is superfluous.

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-param orchestration tool with no output schema and no annotations, missing pieces matter: no list of permitted inner tools, no error-payload description, no guidance on whether refs need re-snapshotting mid-batch. Adequate to call it, but an agent will likely need trial and error on failures.

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 50% and the actions array is opaque (tool is an unconstrained string), so the inline example {tool:"browser_click", args:{ref:12}} is genuinely additive—it shows the nested shape the schema never spells out. The description does not enumerate which tool names are legal inside actions, which is the biggest remaining gap.

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 plainly that it runs several actions in ONE call and saves an agent turn per action, which distinguishes it from the single-action siblings like browser_click or browser_type. It stops short of naming those siblings as the alternative, but the batching purpose 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?

"Úsala cuando ya sabes los pasos siguientes" gives a clear selection cue: use it for pre-planned sequences, not for adaptive flows that depend on intermediate observations. No explicit when-not or named alternative, so it falls short of a 5.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the cursor moves visibly and the click is real CDP Input, but it omits side effects like navigation or form submission, failure behavior, waiting behavior, and what the snapshot parameter 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?

It is a single front-loaded sentence with no filler or repetition. Efficient and easy to scan, though quite terse for a tool with seven optional 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?

There are 7 optional parameters, no annotations, and no output schema, yet the description does not explain click side effects, parameter interactions, or return behavior. For a browser interaction tool of this complexity, the description is incomplete.

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

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

Schema description coverage is 71%, so the schema documents most parameters already. The description only restates that the target can be a ref or x,y coordinates, adding no extra meaning for button, modifiers, clickCount, or snapshot.

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

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

States a specific verb and resource: 'hace clic real ... sobre un ref o x,y', and adds that it is a real click via CDP Input with visible cursor movement. It distinguishes itself implicitly from browser_move, though it does not name any sibling tool explicitly.

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

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

The description gives no guidance on when to use this tool versus alternatives such as browser_drag, browser_element_at, or browser_type. It also does not say when to prefer ref versus x,y, or whether a snapshot must be taken first.

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 disclosure burden. It implies a read of recent console output but does not state whether the operation is read-only, whether it clears the console, how many messages are returned, or what happens when the limit is omitted.

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 zero wasted words. For a simple retrieval tool this is appropriately sized, even though it is under-informative in other dimensions.

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 annotations, no output schema, and an undocumented optional parameter, the description is too thin. An agent cannot confidently determine how many messages are returned, whether the limit parameter controls that, or whether the operation has any side effects on the console buffer.

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

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

Schema description coverage is 0% and the description does not mention the single optional `limit` parameter at all. The word 'últimos' loosely implies recency, but the meaning, default value, and maximum of `limit` are left entirely undocumented.

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 names the resource (console messages and JS errors) and scopes it to the active tab. It is specific enough to distinguish this from generic browsing tools, but it does not explicitly differentiate itself from sibling tools like browser_events or browser_trace.

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_events, browser_trace, or browser_eval. The active-tab context implies a debugging use case, but no exclusions or routing advice is provided.

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

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

No annotations are provided, so the description carries the full burden; it does convey that this is a state-read (position + element under it) rather than a mutation, which is the key safety signal. However, it says nothing about the shape of the response, coordinate system, or what happens when the cursor is outside the viewport or over no element.

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. Nothing could be trimmed without losing 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?

With no output schema and no annotations, the description is the only source of truth about the return value, and it only sketches it (position and element). For a zero-argument getter that is minimally adequate, but the return format and edge cases are left unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify and the baseline of 4 applies. Schema coverage is 100% for the empty object.

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 resource: the agent's current cursor position plus the element beneath it. That is precise enough to know what the tool reports, though it lacks an explicit verb and never distinguishes itself from closely related siblings such as browser_element_at, browser_move, or browser_cursor_style.

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 indication of when to call this versus alternatives like browser_element_at or browser_snapshot, and no stated preconditions. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full burden. It discloses the privacy-mask effect (blurring contacts and numbers during recording or screen sharing), which is genuinely useful, but says nothing about defaults, persistence of state across calls, or what happens to unspecified toggles.

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 enumerating the four capabilities with no filler. It is efficient, though the enumeration is dense and would benefit from a short lead clause about the recording context.

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?

Five optional parameters, no annotations, and no output schema mean the description must carry the behavioral load. It covers the visible effects but omits the teachButton toggle, default behavior when no arguments are passed, and whether settings persist between calls.

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 60%, and the description names four of the five toggles, adding context for the HUD and privacy mask beyond the schema labels. However, teachButton is absent from the description, and no default or omission semantics are given for any parameter.

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

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

States a specific verb pair (muestra/oculta) and enumerates the resources affected: visual cursor, trail, live token HUD, and privacy mask. An agent can distinguish this from siblings like browser_cursor or browser_record_start, though the overlap with browser_cursor is not explicitly resolved.

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 'al grabar o compartir pantalla' hints at the recording/screen-sharing context, but there is no explicit when-to-use guidance, no statement about calling it with zero arguments, and no disambiguation from browser_cursor or browser_teach_start.

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 well: it discloses visible clicks, a hard safety boundary (never accept/subscribe/sign in), and the automatic post-navigate invocation with an env-var override. It omits outcome/reporting behavior (e.g., what happens when nothing matches), so not quite a 5.

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

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

Three tight sentences, front-loaded with the action and examples, then the safety rule, then the automation note. Every clause carries information; no filler.

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

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

For a zero-input tool with no output schema, the description covers purpose, safety boundaries, and auto-invocation. It leaves out failure/empty-state behavior, which is the main remaining gap.

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

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

Zero-parameter tool, so the baseline is 4. There is nothing for the description to disambiguate, and it correctly implies no inputs 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?

Specific verb+resource: 'Cierra popups que tapan la página' with concrete examples (idioma, newsletter, cookies, Google login), which makes clear it's not a generic click. It distinguishes itself from browser_click by restricting to close/reject actions, though it doesn't name siblings explicitly.

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

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

'Ya se hace solo tras browser_navigate (AGENT_AUTO_DISMISS=0 lo apaga)' tells the agent the tool is already auto-invoked and how to disable that, which is real usage context. The when-to-use trigger (popups covering the page) is implied by the constraints rather than stated as an explicit call condition, and there's no guidance on what to do if no popup is found.

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 must carry the full behavioral burden. It discloses only that the button is held during the move; it says nothing about whether the source element is scrolled into view, how the gesture is sequenced (inserted pauses/steps), whether it fails silently on non-draggable targets, or what side effects occur on the page.

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 dense sentence with zero filler, front-loading the core action and mechanism before the examples. It is appropriately sized for a gesture tool, though it could have packed in one more operational detail at the same length.

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 nested, three-parameter interactive mutation tool with no annotations and no output schema, the description leaves too much open: nothing on ref acquisition workflow, scroll-into-view behavior, or result/wait semantics. The from/to coordinate-vs-ref duality is the only complexity it addresses.

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

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

Schema coverage is 33%: the nested from/to properties (x, y, ref) are documented in the schema, but the top-level from/to/snapshot flags are not. The phrase 'de un punto/ref a otro' usefully conveys that each endpoint accepts either coordinates or a snapshot ref, which adds real meaning beyond the schema, but the snapshot parameter is left entirely to the schema.

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

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

States a specific verb (arrastra/drag) plus the source–target resource ('de un punto/ref a otro') and the mechanic ('con el botón pulsado'), which is enough to tell it apart from a simple click. It never names a sibling such as browser_move or browser_click, so differentiation is only implicit.

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

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

The parenthetical examples (sliders, kanban, mapas) imply the class of UI widgets this is for, which is useful context. There is no explicit 'use this instead of X' routing, no prerequisite (e.g. obtaining the ref via browser_snapshot/browser_find first), and no exclusion cases.

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

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

With no annotations, the description carries full burden. It does disclose the return payload (role, text, clickability, DOM path), which is the most useful behavioral fact for this tool. However it does not say what happens when nothing is at that point (null vs error), whether a live browser session is required, or that the operation is a non-mutating lookup.

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 dense sentence with zero filler, front-loading the key differentiator ('Visión por píxel SIN imagen') before the concrete contract. Nothing redundant to cut.

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 small two-parameter read tool with no output schema, the description compensates well by enumerating returned fields. The remaining gaps — coordinate frame and behavior at empty coordinates — are the only things an agent might need in order 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 0%, and the schema declares both params as bare numbers. The description tells the agent x and y are pixel coordinates for a hit-test, which is real added meaning, but leaves the coordinate frame unspecified (viewport vs page vs device pixels) — a critical ambiguity for a coordinate-based tool.

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

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

States a concrete verb and outcome: given (x,y) it returns which element is at that point, plus the shape of what comes back (role, text, clickable, DOM path). The 'SIN imagen' framing implicitly distinguishes it from the visual screenshot approach, so an agent can tell it apart from image-based siblings without opening the schema.

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

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

There is no explicit statement of when to reach for this over browser_find (search by selector/text), browser_snapshot (structure) or browser_screenshot (visual). The 'SIN imagen' phrase hints at the screenshot alternative but never names it or states the selecting condition, leaving the agent to infer usage from coordinates 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 and does disclose one important operational trait: the tool is feature-gated behind AGENT_ALLOW_EVAL=1. It says nothing about execution context, whether page state can be mutated by the evaluated code, async/promise handling, error behavior, or return-value serialization limits.

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

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

Two short sentences with no filler, and the core action is front-loaded ahead of the availability caveat. The definition is efficient, though its brevity comes at the cost of the missing detail noted elsewhere rather than being tight-but-complete.

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

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

For an arbitrary-code-execution tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. An agent cannot tell what the JSON result looks like, what happens on a JS error or timeout, or what side effects on the page are permitted.

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

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

There is one parameter (`expression`) with 0% schema description coverage, so the description must compensate and largely does not. 'Ejecuta JavaScript' weakly implies the string is JS source, but nothing says whether it is an expression vs statements, whether it may be async, or what serialization constraints the returned value must satisfy.

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

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

States a specific verb and resource — runs JavaScript in the page and returns the result as JSON — which is unambiguous about what the tool does. It does not, however, differentiate itself from close siblings such as browser_console or browser_extract, so an agent must infer the boundary.

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 only guidance is an availability condition (disabled unless AGENT_ALLOW_EVAL=1), which is useful but is a gate rather than a when-to-use rule. It never says when arbitrary JS evaluation is preferable to browser_console, browser_extract, or browser_find, nor when it should be avoided.

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. It discloses an incremental 'since last query' scope and lists included event types, but it does not explain whether calling it advances or clears the cursor, whether it is read-only, or how the 'last query' baseline is maintained.

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 wasteful wording. It is efficient, though it lacks a front-loaded verb and is somewhat ambiguous rather than maximally structured.

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

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

With no annotations, no output schema, and no parameters, the description must carry the full context. It enumerates event categories but does not explain the return format, the stateful query behavior, or how the agent should interpret the results.

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 per the baseline this dimension is naturally strong. There is no parameter behavior to clarify or compensate for in the description.

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

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

The description names the event categories it reports (accepted dialogs, saved downloads, opened popups) and implies a list of events since the last query, but it never uses a clear verb like 'list' or 'return' and does not distinguish itself from siblings such as browser_history or browser_console.

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, no prerequisites, and no indication of whether it should be called after other browser actions. The agent is left to infer usage from the event categories 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 at all, the description carries the full burden and does reasonably well: it discloses the auto-selection heuristic (the table/list with the most content), that file mode writes to disk and returns only a summary, and that rows are capped. It does not state read-only-ness, permissions, or failure behavior when no table/list is found.

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

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

Three short sentences, front-loaded with the value proposition ('en UNA llamada') then the resource, then the scoping and file caveats. The opening phrase is slightly promotional but does convey the one-call efficiency argument. No filler sentences.

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?

Six optional parameters with no output schema mean the description must sketch the return value, and it does (rows with title, link, price, image, as JSON or CSV). Combined with the file-mode summary behavior, an agent can call this correctly; only error/empty-result behavior is missing.

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

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

Schema description coverage is 83%, so ref, selector, file, kind and max already carry documentation. The description adds only the file-mode consequence (summary instead of full data) and the meaning of auto; format's json/csv trade-off is not explained beyond the enum itself. Baseline 3 is appropriate.

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

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

States a specific verb+resource: converts the most relevant table or repeated list into JSON/CSV rows. The concrete examples (productos, resultados, contactos) and the field set (título, enlace, precio, imagen) make the output shape unmistakable. It never names a sibling such as browser_read or browser_snapshot, so differentiation is left implicit.

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

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

'Limítalo con ref o selector' hints at how to scope the extraction, and 'con file ... solo devuelve un resumen' clarifies the file variant. But there is no explicit when-to-use-this-instead-of guidance against the many sibling tools (browser_read, browser_snapshot, browser_eval) that also surface page content. Usage has to be inferred from the stated output format.

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 usefully discloses that matches can be returned even outside the viewport and that results include refs and coordinates, but it omits whether this is a pure read operation, permission requirements, result limits, and error behavior.

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

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

The single sentence is front-loaded and has no wasted words. It is efficiently sized, though the compactness contributes to missing parameter and usage details.

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

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

For a two-parameter tool with no annotations and no output schema, the description gives useful return-value context (refs and coordinates) and viewport behavior. However, it leaves the 'max' parameter unexplained and gives no sibling routing guidance, so it 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 0%, so the description must compensate. It vaguely explains that 'query' is text/label based, but does not clarify matching semantics or explain the 'max' parameter at all, leaving half the parameters undocumented in both schema and description.

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 ('Busca') and resource ('elementos por texto/etiqueta') and says what it returns (refs and coordinates). It does not name or contrast with siblings like browser_snapshot or browser_element_at, so it is clear but not fully differentiated.

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 explicit guidance on when to use this tool versus alternatives such as browser_snapshot, browser_element_at, or browser_read. The only implied usage is finding elements by text/label, which is not enough to route an agent reliably.

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, yet it discloses nothing about state effects: whether reload discards unsaved state, whether back fails at history start, or what happens to the page session. Three Spanish words cannot cover a state-mutating browser tool with zero annotation coverage.

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

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

Extremely short with no wasted words, but the brevity is under-specification rather than economy — nothing is front-loaded because there is essentially no content. It also switches to Spanish while sibling tool names and the schema are English, adding friction.

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

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

With no annotations, no output schema, and only half the parameters documented, the description should be doing significant explanatory work. Instead it offers a bare action list, so an agent cannot know return behavior, failure modes, or how the tool relates to browser_navigate and browser_snapshot.

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

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

Schema coverage is only 50%, and the description adds zero parameter meaning beyond what the enum already conveys. The one documented parameter (`snapshot`) is explained in the schema itself; the description neither reinforces it nor clarifies action semantics such as error behavior at history boundaries.

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 three concrete actions (back, forward, reload) that map to browser history navigation, so the intent is inferable. But it is essentially a restatement of the `action` enum and never distinguishes this tool from siblings like browser_navigate, leaving the agent to infer the boundary itself.

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 versus browser_navigate, no mention of whether history entries must exist, and no exclusion conditions. The agent must guess whether 'reload' here differs from a navigate-to-current-URL.

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 usefully discloses that it fires real mouseover/mousemove events (not synthetic), but says nothing about what happens on an invalid ref, whether the element is scrolled into view first, or which target wins when both ref and x,y are supplied.

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, zero waste, with the action and its targeting options front-loaded.

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

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

For a three-parameter, non-mutating interaction tool with no output schema the essentials are present, but the ref-vs-x,y precedence and error behavior on a stale ref remain unstated — the main gaps an agent could hit when calling it.

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

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

Schema coverage is 100% and every parameter carries a description including the ref format example ('f1:7' in iframes), so the schema does the heavy lifting. The description only restates the two target modes and adds no precedence or unit detail beyond the schema.

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

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

Names a specific verb+resource: moves the visible cursor (hover) to a ref or to x,y. This clearly separates it from browser_cursor (presumably querying position) and browser_click, though it never explicitly contrasts with any sibling.

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

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

The parenthetical '(hover)' implies the use case and the two targeting modes are stated, but there is no explicit when-to-use/when-not guidance and no pointer to alternatives such as browser_cursor or browser_click for actually triggering elements.

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 burden, yet it only says what is returned. It omits that navigation replaces the active tab's current page, whether it waits for load, how errors or timeouts behave, and any auth or cross-origin constraints.

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, front-loaded with the action and followed by return behavior. There is no filler and every clause contributes information.

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

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

For a browser navigation tool with no annotations and no output schema, the description is incomplete. It does not explain state-changing effects on the active tab, load/wait behavior, or what the returned snapshot contains, leaving the agent under-informed about a potentially disruptive operation.

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

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

Schema coverage is only 50%: the snapshot parameter is already documented in the schema, and the description merely restates it as optional. The url parameter has no schema description, and the description does not add format or requirement details such as absolute URL expectations.

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

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

The description states a specific verb and resource: opening a URL in the active tab, plus what it returns. It does not explicitly distinguish itself from siblings such as browser_tabs or browser_snapshot, but the core action is clear.

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 browser_tabs, browser_snapshot, or other navigation-related siblings. The mention of the optional snapshot is a parameter behavior, not usage guidance, and no exclusions or preconditions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that multiple keys are space-separated and gives examples, but it does not state focus requirements, whether presses go to the focused element or page, what side effects occur, or what is returned.

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 wasted preamble. The examples and the space-separation note are compact and useful.

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 action with no output schema, the description covers key syntax adequately but omits focus and side-effect context. It is enough to attempt a call, but not enough to fully distinguish it from related browser input 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 coverage is 50%: the snapshot parameter is documented in the schema, while the required keys parameter is not. The description compensates partly by giving key examples and the space-separated sequence format, which adds meaningful syntax beyond the schema, though it is not exhaustive.

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 action ("Pulsa teclas") and resource (keys/combinations) with concrete examples such as "Enter" and "Control+L". It does not explicitly differentiate from sibling browser_type, but the verb and shortcut examples make the scope clear.

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 like browser_type, browser_click, or browser_select. The examples imply keyboard-shortcut scenarios, but the agent must infer the selection conditions.

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 does disclose the return content (readable text) and implies a non-mutating read. However, it says nothing about truncation via maxChars, behavior when the selector matches nothing, whether it waits for page load, or how text is normalized — all relevant to a browser read.

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

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

A single front-loaded clause with no filler; the core (readable text, optional selector) comes first. It is arguably too terse rather than verbose, but on the conciseness axis it wastes nothing.

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

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

No annotations, no output schema, and zero parameter documentation mean the description is the only source of truth, yet it omits truncation behavior, selector semantics, error/empty-case handling, and any routing versus 30+ sibling browser tools. Inadequate for an undocumented two-parameter browser tool.

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

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

Schema description coverage is 0%, so the description must compensate and largely does not. It hints at a CSS selector concept but never links it to the `selector` parameter or states default scope, and it never explains `maxChars` (presumably a truncation limit on returned text).

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 resource and result: readable page text, optionally scoped to a CSS selector, aimed at reading articles or result sets. It is clear enough for an agent to recognize a text-extraction read, though it never distinguishes itself from near-neighbors such as browser_extract or browser_snapshot.

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

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

"para leer artículos/resultados" implies the use case (reading content rather than interacting), but there is no explicit when-to-use, no exclusions, and no pointer to alternatives like browser_extract or browser_snapshot for structured or visual capture. Usage is only inferable.

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 does convey that the tool is a read operation and that the detail mode returns steps and parameters. It omits what happens when 'name' matches no recipe, whether the list is paginated or ordered, and there is no output schema to fall back on.

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 compact sentence with the default behavior front-loaded and the parameter case second; nothing is wasted. It is arguably too short for the tool's two distinct modes.

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

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

For a one-parameter read tool with no annotations and no output schema, the description covers both modes but leaves the return shape, ordering, and not-found behavior unexplained. Adequate, but not more than minimum viable.

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

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

Schema coverage is 0%, so the description must compensate, and it does: 'name' is explained both by its absence (list all recipes) and its presence (show that recipe's steps and parameters). It lacks format hints (exact recipe identifier vs. fuzzy title), but the parameter's effect is clear.

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

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

States a specific verb+resource ('lista las recetas grabadas') and distinguishes two modes: plain listing vs. detail view when 'name' is supplied. It does not explicitly distinguish itself from siblings like browser_replay or browser_record_start, which also concern recorded recipes, so an agent must infer the boundary.

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 conditional 'o, con name, muestra sus pasos y parámetros' implies when to pass the parameter, but there is no explicit when-to-use/when-not-to-use guidance and no mention of alternatives such as browser_replay for actually executing a recipe.

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 real behavior: the cursor overlay is rendered red, idle pauses keep their real duration (so the clip is real-time, not compressed), and the codec falls back from MP4 to WebM when ffmpeg is absent. It omits side effects like where the file lands and what is returned on completion.

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?

Four short sentences, front-loaded with the core action and the start/stop pairing, then pacing and codec caveats. Nothing is repeated from the schema except the one format constraint that matters operationally.

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

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

For a 5-optional-param capture tool with no annotations and no output schema, the description covers the workflow, cursor overlay, timing behavior and codec fallback adequately. The main omission is what the call returns (handle, path, confirmation), which the agent cannot learn from an output schema that does not exist.

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 fps, demo, file, format and maxSeconds. The description only reinforces the ffmpeg dependency behind format, adding little meaning beyond the field descriptions; baseline 3 applies.

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

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

States a specific verb and resource ("Empieza a grabar en vídeo la pestaña activa") plus the distinctive scope (red cursor visible, demo clips). It also names the companion tool browser_record_stop, so an agent can tell exactly which of the record pair to call.

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

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

Explicitly says to keep using the other tools while recording and to finish with browser_record_stop, which defines the workflow context and the terminating alternative. It does not state when not to use it (e.g., instead of browser_screenshot or browser_trace for capture), leaving one gap.

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. It discloses that the tool encodes the video and returns path, duration, size, and format, which is useful behavioral context. However, it does not mention error conditions (e.g., stopping when nothing is recording) or whether the file is written to disk, leaving gaps for a mutation/IO 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?

Two compact sentences with zero waste: the action is front-loaded and the return values follow. 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?

There is no output schema, but the description lists the return values (path, duration, size, format), so the agent knows what to expect. Combined with zero parameters, this is nearly complete, falling short only on error-condition behavior.

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

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

The tool takes zero parameters, so there is no parameter semantics to document. The baseline of 4 applies since nothing in the schema needs compensation.

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 (stops the recording, encodes the video) and explicitly ties it to sibling browser_record_start, so the agent can tell it apart from browser_teach_stop or browser_screenshot. It is clear but does not elaborate on scope beyond that pairing.

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

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

Usage is implied by the reference to browser_record_start (call this to end that recording), but there is no explicit statement of when to use it, prerequisites, or what happens if no recording is active. The pairing gives more than a bare name, but no exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden, and it does disclose two valuable traits: it does not perceive the page (cheap in tokens) and password fields are always typed by the human, implying a human hand-off step. It omits failure behavior (what happens if an element cannot be located), whether the recipe must pre-exist, and what the tool returns.

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

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

Front-loaded with the action, then mechanism, then parameter example, then the password caveat. Four short sentences with little waste, though the example JSON is slightly bulky for the information it conveys.

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 nested-object, three-parameter tool with no annotations and no output schema, the description covers mechanism and token cost but leaves prerequisites (a recorded recipe must exist) and result/failure behavior unexplained; the 'snapshot' return behavior lives only in the schema.

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

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

Schema coverage is only 33%, yet the description compensates for the most opaque parameter: 'params' is explained as overriding written texts, with a concrete example. 'name' is only implicitly the recipe identifier and is never stated as required, and no constraint on param keys matching recipe placeholders is given.

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

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

Names a specific verb and resource: 'Repite una receta grabada' (replays a recorded recipe), and adds the mechanism (locates elements by role and name, executes steps without perceiving the page). An agent can tell this apart from browser_click/browser_type, but the description never names the sibling tools (browser_recipes, browser_record_start) that produce or list recipes.

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

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

Usage is only implied: you call it when a recipe already exists, and the note about secret fields hints that a human is involved. There is no explicit 'use this instead of X' routing, no mention of how recipes are obtained, and no stated condition for when not to replay.

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. It usefully discloses the mechanism (banner shown, waits for 'Listo'/'Cancelar') and an important privacy trait (the agent does not see what the human types). However it omits what happens on timeout or Cancel and what the call returns (confirmation/success flag), which matters for a blocking human-in-the-loop tool.

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

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

Three tight sentences, front-loaded with the action and its triggers, followed by mechanism and the key privacy caveat. Every sentence adds value; nothing is padded.

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

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

For a blocking, human-interaction tool with no annotations and no output schema, the description should explain the outcome of Ready vs Cancel and timeout handling. It covers the mechanism and privacy but leaves the return/result semantics unstated.

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

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

Schema coverage is 100%, so both parameters (reason, timeout in ms) are already documented. The description adds contextual hints about what to put in reason (login, 2FA, CAPTCHA) but nothing about timeout behavior beyond what the schema states. Baseline 3 is appropriate.

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

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

States a specific verb and resource: asks the human watching the browser for help, with concrete triggers (login, 2FA, CAPTCHA, a decision). This clearly distinguishes it from the automation siblings like browser_click, browser_type, browser_eval, which all act without human involvement.

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

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

Names concrete situations when to use it (login, 2FA, CAPTCHA, a decision). No explicit exclusions or named alternatives, but the triggers are specific enough that an agent can decide when to escalate to the human versus acting autonomously.

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 must carry behavioral weight. It does disclose the token cost and the output format (JPEG), which are genuinely useful. It does not state what quality defaults apply, whether the image is returned inline/base64 vs a path, or how it interacts with the current viewport versus full page — gaps that matter for a capture 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?

A single front-loaded sentence with the cost warning first, then the capability, then the qualifying content type. Compact and appropriately sized, though the garbled 'captchas no' fragment costs some clarity.

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

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

For a 3-parameter, zero-annotation, no-output-schema tool, the description covers the 'when' reasonably but leaves the return shape (inline data vs URL), default quality, and fullPage semantics to inference. Adequate to call it, insufficient to call it optimally.

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

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

Schema description coverage is only 33%, so the description should compensate, but it only restates that a screenshot can target 'la página o un ref'. The quality and fullPage parameters receive no explanation anywhere, leaving their defaults and effect (e.g., full document vs viewport) undocumented.

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

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

States a concrete verb+resource: produces a JPEG image of the page or of a given ref, and names the target use case (purely visual content such as canvas or graphics). It implicitly distinguishes itself from browser_snapshot (which yields structure, not pixels) via 'de la página o de un ref'. The trailing 'captchas no' is ambiguous about an edge case but does not obscure the core purpose.

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

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

'ÚLTIMO RECURSO (gasta tokens)' explicitly tells the agent to try other tools first and warns about cost, and 'para contenido puramente visual (canvas, gráficos...)' bounds the qualifying cases. It stops short of naming the preferred alternative (browser_snapshot/browser_extract) or excluding specific scenarios cleanly, since 'captchas no' reads as a truncated caveat.

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 full disclosure burden. It usefully adds wheel-direction semantics for dy and explains that a ref centers the target element — behavior not present in the schema — but it omits whether scrolling is synchronous, what page state changes occur, and any permission or waiting requirements.

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

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

Two short, front-loaded sentences with no filler; the direction rule and ref behavior are stated immediately. Only slightly under-specified rather than bloated.

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 six-parameter, annotation-free tool with no output schema, the description covers dy direction and ref centering but says nothing about the snapshot shortcut, coordinate params, or what the call returns. Adequate but with clear gaps an agent would need to infer.

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 67%, so the schema already documents x, y, ref, and snapshot. The description adds real meaning for the undocumented dy (direction) and clarifies ref as a centering target, but leaves dx, x, and y semantics untouched. A 3 reflects partial compensation for the coverage gap.

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 (Desplaza) and resource (rueda del ratón), with the added refinement that dy>0 scrolls down and that a ref centers that element. This clearly identifies it as a scroll tool, though it does not explicitly name sibling tools like browser_move or browser_cursor to differentiate.

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

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

The description implies usage via 'dy>0 baja' and the optional ref-centering behavior, giving the agent directional context. However, it never states when to choose this over alternatives (e.g., browser_move for pointer movement) or any prerequisites/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 full burden and falls short: it does not state whether selection replaces or appends to existing options (relevant since 'values' is an array, implying multi-select), whether change events fire, or what happens if a value is not found. Only the existence of the action is conveyed.

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 compact sentence with no filler, and the key disambiguator (value vs. visible text) is placed inline. Brevity is close to under-specification but no sentence is wasted.

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 3-parameter mutation tool with no annotations, no output schema, and only 33% schema coverage, the description should explain 'ref', multi-value/multi-select behavior, and the snapshot flag's purpose. None of these appear, so an agent would have to guess at important call semantics.

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

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

Schema coverage is only 33% (only 'snapshot' is documented in the schema), and the description partially compensates by explaining that 'values' can be matched by value or visible text. However, the 'ref' parameter and array/multi-select semantics are left completely unexplained in both places.

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

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

Names a specific action (select options) on a specific resource (<select> element), and adds how options are identified (by value or visible text). This is clearly distinguishable from siblings like browser_click or browser_type at a glance, though it does not explicitly say it is the preferred tool over click for native dropdowns.

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

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

No guidance on when to use this versus browser_click/browser_type on a dropdown, nor on what to do with custom (non-<select>) dropdown widgets. The agent must infer the selection context entirely 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 well: it discloses the exact output shape (ref, role, name, state, center @x,y in pixels), token cost (~15 tokens/element), default viewport scoping and what diff:true returns. It omits read-only status, ref stability across snapshots and behavior when the element limit is exceeded.

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

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

Three dense sentences, front-loaded with the primary-role signal and the no-screenshot constraint, then output shape, then cost and diff behavior. Zero filler.

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

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

No output schema exists, yet the description describes the returned fields, cost per element and diff mode, which is enough to call it correctly. Minor gaps: no note on error/empty-page behavior or how refs map to the action tools that consume them.

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 all four parameters are already documented; the description only restates diff semantics and viewport scoping (via 'elementos visibles'). Baseline 3 applies since the schema does the heavy lifting and the description adds no format or interaction detail beyond 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+resource: a compact list of visible elements with ref, role, name, state and center coordinates, explicitly 'sin captura' (without screenshot), which partly distinguishes it from browser_screenshot. It does not name browser_find or browser_element_at as the complementary lookup tools, so sibling differentiation is only implied.

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?

'PERCEPCIÓN PRINCIPAL' signals this is the default observation step and diff:true usage is explained, but there is no explicit guidance on when to pick this over browser_find, browser_element_at, browser_screenshot or browser_extract, and no stated prerequisites 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?

There are no annotations, so the description carries the full behavioral burden. It discloses that the comparison is session-scoped and gives the screenshot-cost formula, but it says nothing about whether the optional 'reset' mutates state, whether the tool is read-only, or what the response contains. That leaves a meaningful behavioral gap for a tool with a reset parameter.

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 dense sentence with no filler, and the comparison being reported is front-loaded. The parenthetical formula earns its place by explaining how screenshot cost is estimated, though the sentence could be clearer with an explicit action verb.

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

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

Given that there are no annotations, no output schema, and an undocumented reset parameter, the description is too thin. It explains the metric but omits reset behavior, return shape, and usage context, which are all needed for correct invocation.

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

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

Schema description coverage is 0%, and the description never mentions the single parameter 'reset'. It therefore adds no meaning beyond the bare schema and fails to compensate for the low coverage, leaving reset semantics entirely undocumented.

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 specifies what is being reported: tokens returned by agentic-browser this session versus the cost of equivalent screenshots, including the width×height/750 formula. That is a fairly specific resource, though it never states an explicit verb like 'returns' or 'reports' and leaves the reader to infer that this is a stats tool. Sibling tools contain no other stats tool, so differentiation is adequate once the purpose is inferred.

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 indication of when to use this tool versus alternatives, no preconditions, and no mention of when not to use it. It also does not explain what the 'reset' option is for, so an agent has no guidance on whether or when to invoke it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether closing a tab is destructive to page state, what happens when closing the active or last tab, or what the list operation returns — all critical for a tool that mutates browser tab state.

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

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

A single front-loaded sentence with zero filler: resource first, then each action with its relevant parameter in parentheses. Nothing could be removed without losing information.

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

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

For a three-parameter, no-annotation, no-output-schema mutation tool, the description leaves too much unsaid: return values for list, index base, url format, and side effects of close. An agent would likely guess on at least one of these.

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

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

Schema coverage is 0%, so the description must compensate; it does add value by binding 'url' to the 'new' action and 'index' to 'select' and 'close'. However, it omits the url format (absolute vs relative) and whether index is 0- or 1-based, leaving the two non-enum parameters still ambiguous.

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 resource (pestañas/tabs) and enumerates the four supported operations, which is more than a name restatement. It does not distinguish the tool from siblings like browser_navigate or browser_select, so an agent cannot fully infer its scope without reading 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 action list implies when each operation applies (open a new tab, switch tabs, close tabs), but there is no explicit guidance about when to use this versus browser_navigate or browser_select, and no prerequisites or exclusions are given.

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

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

With no annotations, the description carries the load well: it discloses that recording happens in the agent's Chrome with human interaction, that the session ends via a banner button, that selectors are stored by accessibility role/name rather than pixels, and that passwords are never captured. It omits what happens if a session is already running and what permissions or side effects apply to the page.

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

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

Front-loaded with the mode label, then the workflow, then storage guarantees, then the next call — a logical order with little waste. A couple of clauses (element storage, passwords) are adjacent rather than integrated, but nothing is padding.

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

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

For a two-parameter session-start tool with no output schema, the description covers trigger, human interaction model, termination signal, selector strategy, and a security guarantee. Missing only edge cases such as an already-active recording or how to abort without recording.

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

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

Schema description coverage is 100%, so both url and name are already documented in the schema; baseline 3 applies. The description adds no extra detail about the name format or URL expectations beyond the schema's own "buscar-factura" example.

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?

Starts with a mode label ("MODO ENSEÑAR") and a specific verb+resource: start recording a recipe where the human performs the task once in the agent's Chrome. It is clearly separable from browser_teach_stop (the closing step) and from browser_record_start, which it does not overlap with in wording.

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

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

Explicitly states the operating procedure (the person performs the task once, then presses "Terminar" in the banner) and names the mandatory follow-up call to browser_teach_stop. It does not explicitly exclude browser_record_start as an alternative, which keeps it from a 5.

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

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

With no annotations, the description carries the burden well: it discloses that by default the call blocks waiting for the human to press 'Terminar' or 'Cancelar', that it persists a recipe, and that it returns steps plus parameters. It omits what happens on cancel (empty/partial recipe?) and what occurs when the timeout fires, which are the remaining behavioral gaps.

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

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

Three short sentences, front-loaded with the action and then the default blocking behavior and outcome. No filler or repetition.

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

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

For a two-parameter stop tool with no annotations and no output schema, the description covers the action, the default blocking mode, and the return payload (steps and parameters). Edge-case outcomes (cancel, timeout expiry, no active session) are left unstated.

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

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

Schema coverage is 100%, so the schema already documents both parameters; the description's added value is stating the default for `wait` ('por defecto espera...'), a default the schema does not declare. It says nothing extra about `timeout` semantics beyond the schema's millisecond hint.

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

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

States a specific verb and resource (termina la grabación de browser_teach_start) and names the paired sibling tool, plus what it produces (guarda la receta y devuelve pasos y parámetros). It does not distinguish itself from browser_record_stop, another stop-recording sibling, so a small ambiguity remains.

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

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

Usage is implied by the pairing with browser_teach_start (call this to close that session). There is no explicit statement of when not to use it versus browser_record_stop, nor prerequisites such as requiring an active teach session.

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

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

With no annotations, the description must carry the behavioral load; it does disclose what the returned records contain, which is the core value. However, it never states that this is a read-only diagnostic view, the ordering of the returned actions, any cap on entries, or whether the log spans the session or browser lifetime.

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 compact sentence with the salient content (the returned fields) placed before the purpose clause; no filler. The dense parenthetical is justified because each field is informative.

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

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

Adequate for a small read-only-looking tool: the description explains the returned record shape in lieu of an output schema. Gaps remain around the undocumented 'limit' parameter and the scope/retention of the action log, which matter for correct invocation.

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

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

Schema description coverage is 0% and the single parameter 'limit' is documented nowhere; the description does not mention it at all, leaving an agent to guess whether it is a count of actions, a time bound, or a default. It fails to compensate for the coverage gap.

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 resource and verb: the most recent executed actions, enumerating the fields returned (tool, arguments, duration, URL, result) and naming the intent (debugging/auditing). It distinguishes itself from action-performing siblings, though it never contrasts with near-neighbors like browser_history, browser_events or browser_stats.

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 clause 'para depurar o auditar' implies the use case but gives no explicit when-to-use vs the overlapping siblings (browser_history, browser_events, browser_console, browser_stats) and no exclusions or prerequisites.

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 real traits: real keyboard events, an automatic focus click when ref/x,y are supplied, and a hard refusal on password/2FA/card/account fields tied to a {sensitive} state. It omits failure behavior and whether a field must exist before typing.

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

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

Three short sentences, front-loaded with the core action, then the focus behavior, then the safety exclusion. Nothing is repeated from the schema and no sentence is filler.

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

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

For an 8-parameter mutation tool with no annotations and no output schema, the safety and focus semantics are the critical missing pieces and both are covered. Minor gaps remain around result behavior and error cases, though the snapshot flag is already documented in the schema.

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

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

Schema coverage is 88%, so the baseline is 3, and the description earns above baseline by explaining the coupling between ref/x,y and an implicit focus click — context the schema cannot express. Text and the remaining flags are left to the schema.

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

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

States a specific verb and mechanism ('Escribe texto con eventos de teclado reales'), which cleanly separates it from browser_press, browser_click, and browser_select. It never names those siblings explicitly, so differentiation is implied rather than stated.

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

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

Gives a concrete precondition ('Si das ref/x,y primero hace clic para enfocar') and an explicit routing rule for the sensitive-field case to browser_request_human. It stops short of saying when to prefer this over browser_press or browser_select for non-text inputs.

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 it does disclose one meaningful constraint: files must come from folders allowed by AGENT_UPLOAD_DIRS. It omits what happens on rejected paths, whether change/submit events fire, or what the response contains, leaving notable behavioral gaps.

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

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

Two compact sentences, front-loaded with the action and target, with the security constraint appended. No filler; only slight terseness in the parenthetical that could confuse the ref semantics.

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

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

Covers purpose, both modes of targeting, and the folder restriction for a 2-param tool with no annotations or output schema. Missing failure behavior and return-value expectations, so it is adequate but 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 coverage is 0%, so the description must compensate. It explains that 'ref' can target either a file input or a selector opened by clicking that ref, which is real added meaning, and implies 'files' are local paths within allowed folders. It still doesn't state the format of file paths or the array's constraints.

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

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

States a specific verb and resource: attaching local files to an <input type=file> or the selector opened by clicking a ref. This is clearly distinct from sibling tools like browser_click or browser_type. It doesn't explicitly name a sibling alternative, so it stops short of a 5.

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

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

The parenthetical clarifies two modes of use (direct input element vs. a selector opened by a click on the ref), which is useful operational context. However, there is no explicit when-to-use/when-not guidance or routing to alternatives, so usage is only 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?

Without annotations, the description must carry the full burden of behavioral disclosure. It fails to clarify how the four parameters interact, specifically whether the 'timeout' applies only to condition checks or also to the 'ms' waits.

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

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

The description is extremely concise and efficient, communicating the two operational modes (time-based vs. condition-based) in a single, short sentence.

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

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

For a 4-parameter tool with two distinct waiting modes, the description is incomplete. It does not detail the scope of the wait or the expected success/failure behaviors, especially regarding the timeout limit.

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

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

Schema description coverage is 0%, and the description offers no semantic meaning for any of the four parameters. It relies entirely on the agent knowing what 'ms', 'text', or 'selector' represent.

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 identifies the tool's function as waiting ('Espera') and states the resource scope (browser context). It successfully distinguishes this temporal function from most action-based sibling tools by focusing on waiting time or conditions.

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

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

The description provides no guidance on when to use this tool versus alternatives. For instance, it does not explain if this is better used than, say, a polling mechanism like 'browser_watch' for specific use cases.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that waiting does not consume tokens and that the tool blocks until a change occurs, but it says nothing about timeout behavior, what is returned when the wait ends, or whether the call fails on timeout.

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 compact sentence pair with the core mechanism front-loaded and the use case trailing. No filler, though the parenthetical "sin gastar tokens" could be tightened.

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

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

With no output schema and no annotations, the description should explain what a caller gets back after the wait resolves or times out. It covers the trigger conditions well but leaves the result/timeout contract unspecified for a 4-parameter blocking tool.

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

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

Schema description coverage is 100%, so all four parameters (text, timeout, selector, titleChange) are already documented in the schema. The description only illustrates the titleChange case with an example; it adds no syntax or default detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb ("Espera") and the exact trigger conditions: new text, title change, or regex match, with a concrete example ("(3) WhatsApp"). It does not distinguish itself from the sibling browser_wait, which is the most likely confusion point.

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?

"Ideal para vigilar chats, correos o resultados que tardan" gives a clear context of use. However it offers no exclusions or explicit guidance on when to prefer browser_wait or browser_snapshot instead of this tool.

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