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

With no annotations, the description carries the full behavioral burden. It clearly states the primary behavior (accept/OK the dialog), but does not disclose what happens if no dialog is open, whether the action is blocking, or any side effects beyond dismissal.

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 seven words and every word earns its place. It front-loads the action and includes the critical OK qualifier without 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-parameter, no-output tool, the description is nearly complete. The only gap is the lack of guidance on dialog-state prerequisites or fallback behavior, but the concise semantics plus sibling names give enough context for correct use in most 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 tool has zero parameters and schema description coverage is 100%, so there is no parameter documentation burden. The baseline of 4 applies because no additional parameter semantics are needed.

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

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

The description states a specific verb ('Accept') and resource ('the open native dialog'), and adds the OK semantic that clarifies the action. It is clearly differentiated from sibling fx_alert_dismiss, so an agent can select between them without opening schemas.

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

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

The description implies this is for confirming an open dialog with OK, but it does not explicitly state when to use it versus fx_alert_dismiss or fx_alert_state. No exclusions or alternative routing are provided, leaving the agent to infer context from the sibling names.

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 burden. It states the core behavior clearly, but does not disclose edge-case behavior, such as what happens if no dialog is open, or any side effects beyond dismissing the dialog.

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 with no filler. The action-target structure is immediately readable and every word contributes meaning.

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

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

For a parameterless action with no output schema, this is largely complete: the action and target are clearly identified. It only lacks a note on the precondition that a native dialog must currently be open and how the tool handles its absence.

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

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

There are zero parameters and 100% schema coverage, so the baseline is strong. The description adds useful context by identifying 'the open native dialog' as the implicit operand the tool acts on.

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 action (dismiss/cancel) and the target (the open native dialog). This distinguishes it from sibling fx_alert_accept, as cancel is the opposite of accept.

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: call this when an open native dialog should be cancelled rather than accepted. However, there is no explicit guidance about checking dialog state first via fx_alert_state or when to prefer fx_alert_accept.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It communicates that the tool returns the text of an open native dialog, implying a read-only state query, but it does not disclose what happens when no dialog is open, whether it waits for a dialog, or any edge-case behavior. The absence of side-effect information is a notable 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 extremely concise, with a single short phrase and no filler. It is front-loaded and readable, though the missing verb makes it slightly less self-contained than an ideal definition.

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 state query with no output schema, the description gives the core idea but omits useful context like return value behavior when no dialog is present and the fact that this is a non-mutating read. It is minimally viable but has clear gaps.

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

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

The tool has zero parameters, so the input schema is fully self-contained and there is nothing for the description to add. The baseline of 4 applies here.

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 resource ('open native dialog') and the specific datum returned ('Text'), which is clear enough to distinguish this state query from the action siblings fx_alert_accept and fx_alert_dismiss. However, it lacks an explicit verb like 'Get' or 'Return', so it reads as a noun phrase rather than a full action statement.

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

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

No guidance is given about when to call this tool versus alternatives. The phrase 'open native dialog' implies a precondition, but the description does not state that this should be used when you need the current alert text, nor does it mention that fx_alert_accept/dismiss are actions rather than state reads.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes what to click and how to locate it, but says nothing about what happens if no locator is supplied, whether both ref and selector can be used together, or whether the click may trigger navigation or asynchronous changes.

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

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

The entire description is one efficient sentence with no filler. The key scoping detail, that refs come from fx_snapshot, is front-loaded and immediately actionable.

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-looking parameters and no output schema, the description omits the critical constraint that at least one locator must be supplied. It also provides no information about failure behavior or what the tool returns, making it sufficient only for the happy path.

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 add meaning to the parameters. It does clarify that ref is an identifier from fx_snapshot and selector is a CSS selector, but it does not specify whether at least one is required, whether they are mutually exclusive, or which takes precedence if both are provided.

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 ('click') on an element and explicitly names two locator strategies: a ref from fx_snapshot or a CSS selector. This clearly distinguishes it from sibling tools like fx_type, fx_select, and fx_toggle.

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 a workflow: obtain a ref from fx_snapshot or provide a CSS selector. However, it gives no explicit guidance about when to prefer fx_click over sibling interaction tools, and it does not state any exclusions or alternatives.

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

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

No annotations are present, so the description must carry the behavioral burden. It usefully discloses that only names and domains are returned and that the scope is the current origin. It does not explicitly state that the operation is read-only or describe the exact return format, but for a simple cookie lookup the key limitation is captured.

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 free of filler, front-loading the resource and scope. It is a noun phrase rather than a full instruction, which slightly reduces polish, but every word adds 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 parameterless tool with no output schema, the description covers the essential facts: the origin scope and the restricted cookie fields. It could be more explicit about response shape and side-effect-free behavior, but an agent has enough context to invoke it correctly.

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

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

The input schema has zero parameters, so there are no parameter details the description needs to clarify. This matches the 0-parameter baseline of 4; there is nothing missing.

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 clear resource (cookies) and adds meaningful scope: current origin and names/domains only. It lacks an explicit verb like 'get' or 'list,' but the subject and constraints make the tool's intent clear and distinguish it from the sibling page/navigation tools.

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

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

The description implies when to use the tool: when the agent needs cookie names/domains for the current origin. It does not provide explicit exclusions, prerequisites, or comparisons to alternatives, but the intended use case is reasonably inferable from the phrase.

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 transparency burden and does disclose that the input is a function body and that it may return a value. However, it omits material behavior for an arbitrary JS execution tool, such as error handling, async/promise behavior, return-value serialization, and side effects on page state.

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

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

One short, front-loaded sentence conveys the operation, input format, and return behavior with no wasted words. The parenthetical efficiently packs the most important implementation detail.

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 that executes arbitrary JavaScript, the description is too thin: it does not explain how results are returned, whether promises are awaited, what happens on runtime errors, or what page context the script runs in. With no output schema and no annotations, these are significant gaps for an agent deciding whether and how to call the 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?

The schema only says `js` is a string with no description, so the description provides the key meaning: the value is a function body, not a full script, and evaluation may produce a return value. This is genuinely additive, though it does not clarify optionality, async handling, or exact return conventions.

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 verb and resource: execute JS in the page. It adds a useful semantic cue — the script is a function body and may return a value — which clearly distinguishes this from the sibling interaction tools like fx_click and fx_navigate.

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

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

The intended use is implied by the name and description, but there is no explicit guidance about when to prefer fx_eval over dedicated sibling tools, nor any warning against using it where a more specific fx_* tool would be safer. This is acceptable but relies on inference.

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 alone must carry behavioral disclosure. It only states the action and does not mention whether navigation waits for page load, replaces the current page content, what happens on invalid URLs, or 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?

The description is a single, front-loaded sentence with no filler. Every word contributes to the core meaning.

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

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

For a one-parameter navigation tool, the description covers the essential operation and the 'active tab' scope. However, with no output schema and no annotations, important operational details such as load-wait behavior, failure handling, and return value are missing, leaving the agent to infer 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?

The schema has no description for the url parameter, and the tool description merely repeats the word 'URL' without adding format, scheme, or validity requirements. The schema lists zero required parameters, which conflicts semantically with a tool that needs a destination URL, and the description does not resolve this.

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 ('Navigate'), the resource ('the active tab'), and the destination ('a URL'), making the core action clear. It does not explicitly contrast with sibling tools like fx_page or fx_windows, so it stops short of full differentiation.

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

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

There is no guidance on when to use fx_navigate versus alternatives such as fx_page or fx_wait, and no exclusions or prerequisites are mentioned. The phrase 'active tab' implies context but does not explain when this tool should be selected over siblings.

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

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

With no annotations, the description carries the full behavioral burden. 'Current URL and title' implies a non-mutating read of page state, but it does not disclose output format, whether it waits for page load, or other behavior. It is adequate for a simple read-only tool but not richly transparent.

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

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

The description is five words and contains no filler. It is front-loaded with the core purpose and is appropriately sized for a zero-parameter read-only 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?

Given the tool's simplicity, no parameters, and read-only nature, the description is nearly complete. It states what the tool returns, although the exact return structure is not specified and there is no output schema to fill that 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?

The tool has zero parameters, so the empty input schema is fully covered and no parameter documentation is needed. The description adds useful semantic context by specifying exactly what data is returned: the current URL and title.

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 'Current URL and title' clearly indicates the tool returns the current page's URL and title. It implies a read-only getter on the current page resource, which distinguishes it from sibling actions like fx_navigate or fx_click, though it lacks an explicit verb and explicit sibling differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives such as fx_status or fx_snapshot. The description simply states what it returns, without context on when it is appropriate or when another tool should be used instead.

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

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

With no annotations, the description bears the full burden of behavior disclosure. It does mention an allowed root, but it does not state whether the tool writes a file, overwrites existing files, captures the current page, or returns nothing. This is a significant omission for a tool whose side effects and path constraints directly affect invocation safety.

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

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

The description is a single sentence with no filler, but the phrasing is unclear ('View PNG to a file') and the structure buries the key behavioral information. It is concise in length but not in communicative efficiency.

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

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

For a one-parameter tool with no annotations and no output schema, the description is not complete enough. It leaves ambiguous the core action, the constraint semantics, and how the path value should be constructed. An agent would struggle to invoke it correctly or choose it over fx_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?

The schema has no description for the only parameter, and schema coverage is 0%. The description does add some meaning by indicating 'path' is a file path constrained by an allowed root, but it omits details like expected file extension, relative versus absolute format, or whether the path must already exist. It partially compensates but not fully.

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 PNG file and a path, but the phrase 'View PNG to a file' is grammatically awkward and does not clearly state whether the tool captures a screenshot, reads an existing PNG, or writes one. It does not distinguish this tool from sibling fx_snapshot, whose purpose is also image/snapshot related.

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

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

No guidance is given about when to use this tool versus fx_snapshot or any other sibling. The only contextual hint is the allowed-root constraint, which is a path restriction rather than a usage condition, so an agent cannot tell when this is the right choice.

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

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

With no annotations, the description carries the behavioral burden, and it does state the core action and selection mechanism. However, it does not disclose side effects (e.g., change/input event dispatch), behavior when no matching option exists, or whether it waits for re-render. This is minimum viable but not rich.

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

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

The description is a single front-loaded sentence with no filler or redundancy. Every word contributes to the core meaning.

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

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

For a tool with four undocumented parameters, no output schema, and no annotations, a one-sentence description is not enough. The agent still lacks the semantics of ref and selector, any return-value expectation, and any guidance on selecting between label/value.

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 explain the four parameters. It gives meaning to 'label' and 'value' ('option value or visible label') but leaves 'ref' and 'selector' entirely unexplained, forcing the agent to guess their roles.

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

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

The description names a specific verb ('Set'), a concrete resource ('<select>'), and the two selection criteria ('option value or visible label'). This is enough to distinguish fx_select from interaction siblings like fx_click, fx_type, and fx_toggle, which target different controls.

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 instead of alternatives, no mention of when label vs value should be preferred, and no exclusions or prerequisites. An agent is left to infer that it is for select elements from the description alone.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only mentions the output (map with refs) but not any side effects, performance implications, or requirements (e.g., does it require a loaded page?). It doesn't describe the return format or whether it makes a network request. This is insufficient for a tool with zero annotation support.

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 fragment, which is concise and front-loaded with the core purpose. It's not bloated, but it omits some useful context (like what the map contains). Still, for zero-param tools, this level of brevity is acceptable.

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 zero parameters and no output schema, the description should explain what the tool returns and how to use it. It covers the 'use refs' part, but doesn't describe the structure of the map (e.g., what elements are included, how refs are formatted). For a simple snapshot tool, this might be sufficient, but there's room for more detail on expected return 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 has zero parameters, so the schema already covers everything (100% coverage). The description doesn't need to explain parameter semantics. The baseline for zero-param tools is 4, and there's no missing information to penalize.

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 the resource (interactive-element map) and its output (refs), but lacks an explicit verb like 'get' or 'snapshot'. It's a noun phrase that implies retrieval, which is understandable in context but not fully specific. It does distinguish from siblings by mentioning refs for interaction tools, which is useful.

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 indirectly tells the agent that refs from this tool are used in fx_click/fx_type/..., implying this should be called before those interactions. However, it doesn't explicitly say when to use this tool vs. alternatives, nor does it mention conditions like 'call after navigation' or 'when you need element references'. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the information scope (connection, session, current page, navigator.webdriver flag) but does not state whether the call is read-only, whether it can reset or establish a session, or what happens when the connection is lost.

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

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

The description is one short, front-loaded phrase that immediately communicates the tool's subject ('Health') and then lists the specific fields. There is no wasted text, and for a parameterless tool this level of brevity is warranted.

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?

Because there is no output schema, the description must convey what the tool returns. It names the relevant categories, but does not state the return format, whether all categories are always present, or what values look like (booleans, strings, objects). This is adequate for a simple status call but leaves some ambiguity.

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

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

The tool has zero parameters, so the schema already exhaustively documents the input surface. The description's listed status categories are not parameter documentation but still provide useful context about the tool's behavior. A baseline of 4 is appropriate for a 0-parameter tool.

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

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

The description names the tool's resource—health/status—and specifies the exact status categories: connection, session, current page, and navigator.webdriver flag. It is clear enough to distinguish from sibling tools, though it lacks an explicit verb and does not compare itself to 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?

No guidance is given on when to use fx_status versus alternatives. The description does not state whether to use it before other commands, for diagnostics, or as a health check, leaving the agent to infer its role from the name and siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'set checkbox/radio state' without explaining whether it toggles or sets an absolute value, how it selects the target (via ref or selector), or any side effects. This is insufficient for an agent to predict behavior.

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

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

The description is extremely concise (one sentence), but it is under-specified rather than efficiently concise. It lacks any structured guidance or additional context that would make the brevity helpful. The absence of detail makes it an inadequate representation of the tool's purpose.

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 three parameters, no annotations, and no output schema, the description is severely incomplete. An agent cannot determine how to construct a valid call or what to expect as a result. The description fails to provide essential context 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?

The schema has three parameters with only 'on' having a description ('default true'), giving 33% coverage. The description does not explain the roles of 'ref' or 'selector' or how 'on' relates to the state. With such low schema coverage, the description must compensate, but it adds no parameter-level 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 clearly states the action ('set') and the resource ('checkbox/radio state'). It is specific and understandable, though it does not explicitly differentiate from sibling tools like fx_click or fx_select. The verb-resource combination is sufficient for a basic understanding.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention contexts such as 'use this to change the checked state' or differentiate from clicking or selecting options. Without any sibling comparison or usage conditions, an agent cannot determine when this is the right 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, the description carries the full burden of behavioral disclosure. It does disclose the key clearing behavior and the keep override, which is valuable. However, it does not mention actionability, waiting, focus, event triggering, or failure behavior, leaving notable gaps for a browser automation type action.

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

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

The description is one short, front-loaded sentence that communicates the core action and the most important behavioral modifier. There is no wasted text, and every word earns its place.

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

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

The tool has four parameters with no required markers, no annotations, and no output schema, yet the description only clarifies the keep behavior. The agent is left without understanding how to identify the target element via ref vs selector, making the definition incomplete for reliable 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 only 25%, and only 'keep' has schema documentation. The description adds no meaning for 'ref', 'text', or 'selector', leaving the agent to guess which identifier is required and how text is interpreted. It does not compensate for the low 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 states a specific verb ('Type'), a resource ('text into element'), and a clear behavioral nuance ('clears first unless keep=true'). This makes it distinct from siblings like fx_click and fx_select without needing to inspect schemas.

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

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

The description implies the tool is for entering text into an element, but it does not explicitly say when to prefer it over alternatives, nor does it state exclusions or conditions. The 'clears first unless keep=true' detail is the only usage-specific guidance, so it remains mostly 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It reveals the raw-path sendKeys mechanism and the root-path restriction, which are useful, but it does not mention side effects (e.g., triggering change events), prerequisites, or failure modes for non-file inputs.

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 the action front-loaded and the constraint separated clearly. It is concise, though the parenthetical 'raw-path sendKeys' is slightly cryptic.

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

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

Given no annotations, no output schema, and three opaque parameters, the description is insufficient. It only covers the action and path constraint, leaving ref and selector semantics unexplained, which are likely essential for calling the 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% and the description only clarifies 'path' via the root constraint. The 'ref' and 'selector' parameters remain completely unexplained, leaving the agent without the meaning or relationships needed to invoke the tool correctly.

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 ('Set a file input value') with a clear resource (file input) and a technical hint ('raw-path sendKeys'). It is distinct from siblings like fx_type or fx_click, which handle typing or clicking, not file input assignment.

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

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

The description gives an important constraint ('path must be under FX_MCP_FILE_ROOTS') but does not explicitly state when to prefer this tool over alternatives like fx_type. Usage context is implied by the purpose rather than stated directly.

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

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

With no annotations, the description carries the behavioral burden and does usefully disclose the default 10s timeout and 30s maximum. However, it doesn't say what happens when the wait times out, whether the tool polls, or how text matching works. For a presumably non-destructive wait operation, this is a moderate gap rather than a contradiction.

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 definition is one efficient sentence that front-loads the action and condition, then adds timeout defaults. Every phrase carries useful information with 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 simple wait tool with no output schema and no annotations, the description covers the core wait condition and timeout behavior, making it minimally usable. It is incomplete in important operational details: timeout outcome, parameter precedence, and matching semantics. Given the three optional parameters, a bit more detail would be needed for a 4.

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 does connect text to 'visible text', selector to 'CSS selector exists', and timeout_ms to the default and max duration, which is meaningful. But it omits details such as precedence when both text and selector are supplied, whether text is exact or substring, and the valid timeout_ms range.

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 operation: wait until visible text appears or a CSS selector exists. This clearly distinguishes it from navigation, clicking, and typing siblings, though it doesn't explicitly name a sibling. The timeout default and maximum add further clarity about the tool's scope.

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

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

The description implies the tool is for synchronization before interacting with the page, but it never explicitly says when to use it versus alternatives like fx_status or fx_snapshot. There are no when-not-to-use instructions or references to sibling tools, leaving the agent to infer the usage context.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It names the core action but does not reveal side effects on the previously active window, behavior for invalid handles, or whether the switch has any persistence or side effects.

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

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

The description is seven words, front-loaded, and free of filler. It is efficient, though the brevity contributes to missing behavioral and usage 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?

Even for a one-parameter tool, the schema lists the handle as not required, but the description does not explain what happens when it is omitted. It also does not connect this tool to sibling fx_windows for obtaining valid handles, leaving important operational gaps.

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

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

The phrase 'by handle' gives minimal context that the handle identifies the target window, but with 0% schema description coverage the tool should clarify where handles come from and what format they take. The description does not compensate for that 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 a specific verb ('Switch') and resource ('active window'), and mentions the handle mechanism. It avoids tautology and is implicitly distinct from siblings like fx_windows, but does not explicitly differentiate from related navigation 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?

There is no guidance on when to use this tool versus alternatives such as fx_windows or fx_navigate. It does not mention prerequisites like obtaining a window handle or contexts where switching is appropriate.

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

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

Because no annotations are provided, the description carries the full burden of behavioral disclosure. 'List windows (focused marked)' conveys a non-destructive listing behavior and an output detail about focus, but it does not say what fields or identifiers each window entry contains or whether any state changes occur.

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—four words plus a meaningful parenthetical. Every part adds information, and there is no filler or redundancy.

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

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

For a no-parameter list command, 'List windows (focused marked)' provides a minimal but plausible contract. However, without an output schema, the description does not specify the shape of the returned list or how window identifiers are represented, which may be needed for follow-up actions like navigation.

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

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

The tool has zero parameters, so the description does not need to explain parameter meaning. The empty input schema already communicates that no arguments are required, and the description adds no conflicting information.

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

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

The description uses a specific verb ('List') and resource ('windows') and adds that the focused window is marked, which gives the agent a clear sense of the tool's output. It is reasonably distinguishable from sibling tools like fx_window based on plural versus singular, but it does not explicitly call out the distinction.

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 fx_windows versus fx_window, fx_navigate, or fx_snapshot. The description only states what the tool does, leaving the agent to infer the appropriate context for calling it.

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