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

No annotations are provided, so the description carries the behavioral burden. It clearly states the tool 'empties' (비운다) the picked items, which signals a destructive/clearing operation. However, it does not disclose whether the operation is irreversible, what exactly gets cleared (all picks vs. recent ones), or whether confirmation is needed. The core effect is conveyed, but the details are thin.

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

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

The description is two short sentences: first states the action, second states when to use it. Every word contributes meaning, and the core information is front-loaded. No filler or redundant schema repetition.

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

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

For a zero-parameter tool with no output schema, the description provides the essential facts: what it clears and the occasion for using it. It could be slightly more explicit in defining what '짚어 둔 것' are, but this is clarified by sibling tool names and the context of a story-starting workflow. The description is adequate, though not exhaustive.

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

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

There are no parameters and the schema already fully covers them (100% coverage). With zero parameters, the description has little to add about parameter semantics. The baseline of 4 applies; the description's contextual note about starting a new story provides some extra purpose but no parameter-specific guidance is needed.

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

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

The description states a clear action: '짚어 둔 것을 비운다' ('empties what was picked/pointed out'). This clearly identifies the tool as clearing collected 'picks' and distinguishes it from sibling tools like list_picks, latest_pick, and wait_for_pick. However, the resource is phrased indirectly ('짚어 둔 것') rather than explicitly named 'picks,' so it relies on context.

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 an explicit usage context: '새 이야기를 시작할 때' ('when starting a new story'). This tells the agent when to use the tool but does not mention exclusions or compare it to alternatives, such as using list_picks before clearing or avoiding it mid-story.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The text makes clear that the tool itself is merely a guide and does not perform a direct picking or state-changing browser action, which helps set the right expectation. It does not detail output format, but the purpose of a human-facing guide is sufficiently 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?

The entire description is a single sentence that conveys the audience, the required action, the installation channel, and the one-time usage characteristic. No redundancy, no filler, no explanation of obvious 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 zero-parameter, no-output-schema tool used once at the beginning, the description provides the core needed context: who the instruction is for, what it changes in the browser, and that it is a one-time prerequisite. It could mention what the tool returns or how to complete the given instructions, but for the minimal meta purpose this is sufficient.

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

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

The tool accepts zero parameters, so there is no parameter meaning to be lost. The description does not need to compensate for any schema gaps because none exist.

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

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

The description clearly states that this is a guide to hand to a person for turning on the browser picking feature via bookmarklet or console. It distinguishes itself from the sibling tools that perform actual picking/page actions by framing itself as a one-time explanatory resource rather than an operation.

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 '처음 한 번 필요하다' (needed only once at the beginning) gives explicit timing context for when this tool should be used. It does not explicitly name alternatives, but the one-time setup nature clearly separates it from the recurring pick and page tools.

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

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

Since no annotations are provided, the description carries the full behavioral burden. It discloses one useful trait: the tool is non-blocking and operates on the current state only, not waiting for a new pick. It does not however state whether calling it mutates anything, what happens when no pick exists yet, or what exactly is returned, so transparency is adequate but incomplete.

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

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

The description is very short, front-loaded with the main purpose, and every phrase earns its place. The first sentence states the resource; the second gives the decisive behavioral contrast of not waiting and seeing only current state. There is no filler or redundant restatement.

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

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

For a zero-parameter getter, the description is mostly sufficient and the no-wait behavior is important context. But there is no output schema, and the description does not clarify what the returned value looks like or what the tool does when no pick has occurred. Those gaps matter for an AI agent deciding how to use the result or how to handle an empty state.

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

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

The tool takes zero parameters, so the input schema carries little meaning. With 0 params, the baseline is 4, and the description does not need to compensate for parameter documentation. Nothing about parameters is missing or 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?

The description identifies a specific resource, '가장 최근에 짚은 곳' (the most recently picked place), and gives the essential verb concept of '본다' (looks/retrieves what is currently there). It also differentiates itself from wait_for_pick by emphasizing '기다리지 않고', so the purpose is clear. It stops short of 5 because 'pick' is never explicitly defined and the retrieval verb is somewhat vague.

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 '기다리지 않고 지금 있는 것만 본다' gives the agent a clear usage context: use this when the current, latest picked value is wanted immediately, without waiting for a future pick. This also contrasts naturally with the sibling wait_for_pick. However, the description does not explicitly name alternatives like list_picks or explain when not to use it, so it misses 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It does state ordering; newest first, and implies read-only listing, but it does not explain whether it destroys anything, how it handles empty state, or if there are side effects. For a simple list read this is adequate but thin, so a 3 is appropriate.

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

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

A single short Korean sentence is concise and front-loaded with the core behavior: viewing recent picks with ordering. It does not waste words or repeat schema information, although it could have included a tad more context without becoming 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 one-parameter listing tool without an output schema, the description states the relevant ordering (newest first) and recency of items, but the word 'picks' is not clearly defined in the context of these sibling tools. Simple enough that an agent might infer it, but there is room to specify output shape or edge cases.

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

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

The only parameter 'limit' has a full description in the schema ('how many, default 10'), covering 100% of parameters. The tool description adds no extra meaning for the limit parameter, so the baseline score of 3 applies without bonus.

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 'recently picked places, newest first' clearly identifies the task as listing picks in reverse chronological order. It distinguishes from sister tool latest_pick by implying multiple items rather than a single newest one, though it could be more explicit about that contrast.

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

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

There is no guidance about when to use this tool versus alternatives like latest_pick or clear_picks. The phrase 'recently picked' hints that it is appropriate for seeing recent entries, but it does not state circumstances, exclusions, or why an agent might select it over a sibling tool.

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

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

With no annotations provided, the description carries full burden, and it carries it well. It discloses that the click is a real, impactful action that can save/delete/send, and that it does NOT click when multiple matches occur — it instead returns a list. This is exactly the kind of side-effect/cancellation behavior an agent needs to know.

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 compact and front-loaded. '화면의 무언가를 누른다' states the core action first. Each sentence earns its place: method of finding, realness/severity of clicks, and ambiguity/return behavior. There is no filler.

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

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

With 4 optional parameters and no output schema, the description covers the most important behavior: real click, side effects, find-by-selector/text, and ambiguous-match behavior with nth. It could be slightly more explicit about page parameter before invocation, but the schema already documents it. Overall, essential information is present.

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 each parameter has already has clear descriptions (selector, text, page, nth, 1-based index). The description adds tells how targets can be found ('CSS selector 또는 visible text') and mentions visual text, which maps to the 'text' parameter, but it does not meaningfully explain parameter semantics beyond the schema.

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

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

The description clearly states a verb ('누른다' - clicks) and a specific resource ('화면', the screen). It also explains how it finds targets (CSS selector or visible text) and that it performs real clicks with side effects like save/delete/send. This distinguishes it well from click-like tools such as page_collect or page_look, even without naming siblings.

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

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

The usage context is implied: use this tool when you want to click something visible on the page. It also gives one internal usage rule: when multiple elements match, it returns a list instead of clicking, and then nth should be provided. However, it never contrasts itself with alternatives like page_collect or page_run, or states when not to use it.

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

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

With no annotations provided, the description carries the full burden, and it does disclose an important behavioral trait: the tool not only fills the input but also fires the necessary value-change event so framework-managed fields work. This is genuinely useful context beyond the schema, though it does not mention submit behavior or failure outcomes.

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

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

The description is two short, purposeful sentences with no filler. The core action is front-loaded, and the React value-change detail is added only as a second sentence because it is an important behavioral edge case.

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

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

For a 5-parameter tool with no annotations and no output schema, the description conveys the main action and one important nuance but does not explain what happens on submit, how nth/page apply, or what failure indications might look like. It is minimally viable, not comprehensive.

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

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

The schema already documents submit, page, and nth, and the description loosely indicates that text is the content and selector is the target input. With 60% schema coverage, the description adds modest value for the two undocumented parameters but does not deeply compensate for the gaps.

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

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

The description states a specific action—putting text into an input field—which is not a tautology and is more precise than generic synonyms. It also adds the React value-change dispatch behavior, which helps differentiate it from keyboard or click tools. It does not explicitly name sibling tools, but the verb and resource distinction is clear enough.

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 remark that it triggers value changes so it works in React-like contexts implies a use case, but there is no explicit guidance about when to choose this over page_key or another alternative. Context is implied, not stated as a decision rule.

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 itself must convey behavioral traits, and it does communicate that this is a state-changing navigation action on an existing tab. However, it does not disclose whether the tool waits for page load, whether it can fail on invalid addresses, or whether it replaces the current tab rather than opening a new one.

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

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

The description is a single short sentence with no redundancy or filler. It front-loads the essential ideas: target is the current tab, action is navigation, goal is a different address.

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

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

For a simple navigation tool, the description plus schema is enough to understand the basic call: provide a target address and optionally specify a tab. It is still missing context about return behavior, loading expectations, and when this tool is intended to be preferred over browser-level alternatives.

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%, so the description should compensate for the undocumented `url` field. The phrase '다른 주소' adds navigation meaning to that parameter, but it does not explicitly map to the parameter name, and it says nothing about the `page` parameter or how it disambiguates tabs.

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 Korean description states a clear action: move the currently viewed tab to another address, which unmistakably identifies this as a navigation command. It distinguishes itself from siblings like page_click and page_fill in behavior, but it does not explicitly name or contrast those alternatives, which keeps it from a 5.

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

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

The description provides no explicit guidance on when to use page_goto instead of page_click, page_run, or another page-level tool. There is no when-to-use/when-not-to-use statement, so an agent must infer appropriateness from the tool name and sibling list.

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 disclosure burden. It only says 'presses a key' and does not mention whether the key press goes to the focused element, the optional selector target, or whether it can cause side effects like tab navigation or focus 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?

A single front-loaded sentence with no filler. The examples are immediately useful and directly relevant to the single required parameter.

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

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

The overall tool context is not fully established: there are no annotations or output schema, and the description omits important behavioral details such as focus handling, optional targeting context, and expected execution outcome.

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 75%, so most parameters are already documented. The description adds value for the key parameter by listing concrete acceptable values, but adds nothing for nth, page, or selector beyond what the schema already explains.

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 precise action, '키를 누른다' (presses a key), with concrete key examples. The verb-and-object pairing clearly distinguishes it from page_navigation, clicking, and filling tools among the siblings.

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

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

No usage context, when-to-use guidance, or alternatives are provided. The description simply says 'presses a key' without explaining when to choose this over page_click, page_fill, or other sibling tools.

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

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

There are no annotations, so the description carries the full behavioral burden. It explains that the output represents currently picked tabs and how that output is consumed by manipulation tools. It does not disclose the exact return shape, what the values look like, or edge cases such as an empty list, and there is no output schema to fill that gap.

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

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

The description is a single compact sentence with the subject stated first and the usage context immediately following. There is no filler or repeated structural 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 zero-parameter listing tool, the description is mostly complete: it tells the agent what data is available and how to use it. The main missing piece is an explicit statement of the returned value's shape, especially without an output schema, but the intended use is still inferable.

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

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

The input schema has zero properties, so parameter semantics are irrelevant here. Schema description coverage is 100%, and the description correctly avoids inventing parameter details.

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 identifies the tool as showing tabs that currently have 'picking' enabled, which matches the page_list name and its role of selecting a page. It does not use an explicit verb like 'returns a list,' but the resource and state are clear. It is distinguishable from the manipulation tools, though it does not explicitly differentiate itself from sibling pick tools such as list_picks.

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

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

The description gives a concrete usage scenario: when more than one tab is picked, manipulation tools ask which tab is intended, and the agent should call page_list and pass the chosen value to page. This is clear and actionable. However, it does not name alternative tools or say explicitly when not to use it.

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

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

With no annotations supplied, the description carries the burden of behavioral disclosure. It clearly indicates this is an observation operation and specifies exactly what will be read: URL, title, window size, visible text, and clickable elements. The note that the screen may have changed adds useful situational context.

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

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

The description is compact and well-structured: it states the main behavior, enumerates subject matter, and closes with practical usage guidance. Every sentence adds value, and there is no repetition or fluff.

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

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

For a tool with two optional parameters, a fully documented schema, and no output schema, this description provides sufficient context. It explains why and when to call the tool plus the content of the returned information, so an agent can select and invoke it correctly without missing pieces.

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 parameters are already documented in the input schema. The description adds no parameter-level detail beyond the schema, so it meets the baseline without providing extra semantic value.

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

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

States a verb ('읽는다') and a specific resource: the screen a person is looking at. It also enumerates what is captured — address, title, window size, visible text, and clickable elements — making the tool's read-only role unmistakable relative to sibling action tools like page_click and page_goto.

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

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

Explicitly instructs the agent to call this tool first, before deciding what to do, and gives the rationale: the screen may have changed. It clearly articulates when to use it, though it does not explicitly name alternatives or say when not to use it.

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

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

Since no annotations are provided, the description carries full responsibility for behavior. It clearly discloses the visible effect: show the user the element, draw a highlight, and attach a message. It is slightly less transparent about whether the highlight persists or whether any page state is changed, but the core behavior is well described.

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

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

The description is short and well-structured: it states the action, the visible result, and a clear use case. A tiny redundancy between the parenthetical example and the following explanation keeps it from being fully compact.

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

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

Given the tool has no output schema and only four simple parameters, the description plus the schema is very sufficient for callers. The main missing point is that page_point does not say whether it has any lasting or permanent side effects, such as leaving an annotation after the call.

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

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

The schema already describes most parameters (nth, say, page), so the description adds little beyond a broad confidence. It reinforces the purpose of selector and say, but it does not clarify what selector is or give details about return values. With schema coverage at 75%, the description does not need to do all the heavy lifting but also does not add significant extra meaning.

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

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

The description uses a specific verb '짚어 보인다' (point out) and explains the mechanism: draws a highlight-like border and attaches a word. This clearly distinguishes page_point from siblings such as page_click or page_fill, making its purpose immediately recognizable.

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

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

The description explicitly says to use this when discussing what to fix, instead of explaining verbally. This gives a clear usage context, though it does not name sibling tools or explicitly say when not to use other page_* tools.

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

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

Discloses important behavior: it runs in the page, supports await, and returns the value of the last expression. It does not mention error handling or side effects, but for a JavaScript-execution tool the central effect is clearly stated, and no annotations were provided to rely 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?

Three short, purposeful sentences with no filler. The main verb is named first, followed by usage context and behavioral details needed to invoke the tool.

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

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

With no output schema and no annotations, the description explains the return convention and the supported JavaScript capabilities, which is the core missing context. It does not specify error/timeout conventions, but for a fallback automation tool this is still a sufficiently useful definition.

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 page parameter is already documented in the schema, while the description adds meaningful semantic for the js parameter: it is a command string that can use await and whose final expression is the result. This compensates for the moderate schema coverage and gives actionable input rules.

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 that it executes JavaScript inside a page and returns the result, which is a specific action on a clear resource. It also describes example operations (measuring, scrolling, resizing, multiple steps) and distinguishes itself from the specialized sibling page tools.

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

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

Explicitly positions the tool as the fallback for anything the other page_* tools cannot do, giving strong when-to-use guidance. It does not name the specific sibling tools as alternatives, but the exclusion is likely clear enough from the surrounding tool set.

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 load, and it does explain waiting, returning the selected position, and returning immediately if a pick already exists. However, it does not disclose timeout behavior, what happens when no pick occurs, or whether the call mutates or persists any internal pick 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?

Three concise sentences cover the action, the preferred usage context, and a key optimization. Each sentence is useful, there is no redundant repetition of the schema, and the primary behavior is 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?

The tool has only one optional parameter and no output schema, so the description communicates the basic interaction well. Still, it leaves out the return value's concrete shape (e.g., coordinates versus element reference) and fails to state what occurs after timeout, which are relevant for an agent deciding how to handle the response.

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

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

The schema already fully documents timeout_sec with a clear summary and default value. The description adds the contextual fast-path condition, but it does not add new meaning to the parameter itself, so this dimension stays at the baseline for full schema coverage.

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

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

The description clearly defines a specific verb and resource: it waits until a person taps on the screen and then returns that spot. It does not explicitly contrast itself with siblings such as latest_pick or clear_picks, but the wait-for-interaction behavior is semantically distinct enough for the reader to understand the tool's core function.

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

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

The description gives explicit usage direction: instead of asking 'where should I fix it', call this tool. It also notes the immediate-return behavior when a pick already exists, which guides the agent in expecting a likely cheap call or a potentially blocking wait depending on state.

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