react-native-eye

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

With no annotations, the description carries the full burden and does real work: it discloses the auto-discovery mechanism (walking the React tree for the react-navigation container ref), the precedence rule for globalThis.__RNE_ROUTE__/__RNE_NAV__, and the explicit failure mode (route null plus a hint explaining why). It stops short of describing read-only semantics or how many/which 'recent errors' are included.

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 payload summary is front-loaded in the first sentence, with mechanism and fallback following in descending priority. The parenthetical about globalThis is slightly dense but genuinely informative, and no sentence is filler.

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

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

There is no output schema and no annotations, so the description must define the response — it names the three components and the null-route edge case but never describes the actual shape (route object fields, store state serialization, error list size/format). Adequate for a call decision, incomplete for interpreting the result.

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

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

The single parameter has 0% schema description coverage, so the description must compensate — and it does, explaining that `path` is an optional dot-path into the store state, which tells the agent both its purpose and that it can be omitted. It does not state the default (whole store) or the path syntax, keeping it below a 5.

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

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

States a specific action (one-shot snapshot) and enumerates exactly what it returns: current route, store state at an optional dot-path, and recent errors. This is far more concrete than the sibling names get_state/get_errors, but the description never names those siblings or explains how this combined snapshot differs from calling them separately, leaving differentiation to inference.

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 word 'one-shot' plus the combined payload imply this is the quick triage call rather than a targeted getter, and it notes no app-side setup is required. However there is no explicit when-to-use/when-not guidance and no mention of alternatives like get_errors, get_state, or observe, so routing between them is left implied.

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

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

With no annotations, the description carries the full burden. It does disclose useful non-obvious behavior: default port scanning and that the app's JS runtime is selected automatically. However it says nothing about idempotency (what happens if already connected), timeouts, failure modes, or whether an existing session is replaced — meaningful gaps for a stateful connection tool.

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

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

Two compact clauses, front-loaded with the action and then the argument options. No filler, no restating the tool name, and the default-scanning fallback is stated inline rather than in a separate sentence.

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

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

No output schema and no annotations mean the description is the only source of behavioral detail, and while it covers parameters and default discovery, it omits what a successful connection yields and how errors surface. Adequate to call the tool, but thin for a session-establishing operation that everything else depends on.

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

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

Schema coverage is 0%, so the description must compensate, and it does name all three parameters with meaning: port, target_id (sourced from list_targets), and device name. The 'or' framing also implies these are alternatives, which the bare schema does not convey. It lacks format detail for device (name vs UDID) and precedence rules if multiple are supplied.

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

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

States a specific verb and resource — 'Connect to a running React Native app via Metro' — which is unambiguous and clearly distinct from sibling tools like list_targets or ping. It does not explicitly say how it differs from connect-adjacent siblings (e.g., launch_app), but the resource and transport are named precisely.

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

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

Gives clear context for the two modes of use: pass one of port/target_id/device, or rely on default port scanning. It names list_targets as the source for target_id, which routes the agent correctly. It stops short of stating prerequisites (app must already be running, Metro must be up) or what to do if connection fails.

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

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

With no annotations, the description carries the full burden and does well: it discloses promise awaiting, the Hermes no-async/await constraint, and the semantics of background mode and result collection. It omits the most consequential trait — that this executes arbitrary code in the app with side effects and potential to mutate app 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?

Front-loaded with the core purpose, then constraint details in a tight sequence. The parenthetical examples earn their place by showing valid promise usage, though the sentence structure is slightly dense and runs together multiple rules.

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

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

No output schema exists, and the description plus schema together convey the return behavior (immediate result vs job id). What is missing is safety/error context — whether failures throw, what happens on timeout — which matters for an arbitrary-code-execution 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 coverage is 75%, and the description meaningfully supplements it: it explains what background: true does behaviorally and how its result is retrieved, beyond the schema's 'return a job id immediately'. 'code' and 'label' are left to the schema, which is acceptable at this 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?

States a specific verb and resource ('Evaluate JavaScript in the app's runtime and return the result'), which is unambiguous. It does not, however, distinguish itself from sibling 'profile_js', which likely also executes JS, leaving the agent to infer the boundary.

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

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

Gives concrete guidance on when to pass a promise vs await, and explicitly says to use background: true for work outliving one call and to collect via get_job — naming a sibling correctly. It stops short of saying when NOT to use this tool or how it differs from profile_js/get_state.

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

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

With no annotations, the description carries the full burden and does substantial work: it defines what counts against budget, states that LogBox/overlay/root-tag-context nodes are omitted entirely, and that oversized trees are capped and flagged truncated rather than returned unbounded. What it leaves out is failure behavior — what happens if the React DevTools hook isn't present — and required app/connection 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 sentences, front-loaded with the purpose, then parameter semantics, then output filtering and truncation. Parenthetical examples are dense but each earns its place; there is no filler or restatement of the name.

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

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

For a single-parameter read tool with no output schema and no annotations, it covers content of the returned nodes, exclusions, and truncation marking. The remaining gap is the response shape (nested tree vs flat list of nodes) and the runtime precondition for the DevTools hook, which an agent would need before calling.

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

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

Schema coverage is 0%, so the description must compensate, and it does: max_depth is explained as counting only developer-authored components, with host components, forwardRef/memo/context and styling HOCs explicitly free and repeatable. That is a real semantic rule an agent could not derive from the bare integer schema with a 1–10 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?

States a specific verb+resource: a depth-limited React component tree obtained via the React DevTools hook, enriched with testID and text. The resource is distinct enough from neighbors like get_layout or read_screen_text to be selectable, but the description never names a sibling or explicitly contrasts itself with them.

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

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

Usage is only implied: an agent can infer this is for inspecting the React component hierarchy on a connected RN app, and that dev-only infrastructure is filtered out. There is no explicit 'use this when…' or 'prefer X instead' guidance, and no mention of prerequisites such as the DevTools hook being available or the app running in dev mode.

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

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

With no annotations, the description carries the full burden. It usefully discloses the capture window ('since connecting') and the unusual coverage (LogBox-swallowed errors that bypass the debugger), which is genuine behavioral value. It says nothing about ordering, whether results accumulate or are cleared, or what happens past the limit, so the transparency is partial.

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

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

Two tight sentences with zero filler, and the core scope is front-loaded in the first sentence before the LogBox qualifier. Every clause adds information an agent could not get from the name alone.

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-annotation, no-output-schema tool, the description adequately conveys what data is returned and over what time window. However, it omits the limit parameter's behavior and any sense of result shape or volume, leaving gaps an agent would need to discover by calling.

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% for the sole parameter 'limit', which has a max of 100 and an exclusive minimum of 0 but no documented meaning. The description never mentions limit at all, so it fails to compensate for the coverage gap; an agent must guess whether it caps error count, is a default of all, or affects ordering.

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

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

States a specific resource with a verb implied by the noun: 'Uncaught exceptions and redboxes captured since connecting.' The second sentence sharpens the scope further by naming LogBox and noting these errors never reach the debugger, which implicitly separates it from get_logs. It never names the sibling explicitly, so differentiation is inferred rather than stated.

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

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

There is no explicit 'use this when...' guidance and no named alternative such as get_logs or read_screen_text. The usage is inferable from the content scope (errors since connecting), which is enough for an agent debugging a failure, but the boundary versus get_logs is left to 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?

No annotations exist, so the description carries the full burden. It does disclose a genuinely important behavioral trait: results are platform-dependent, with real UI-thread frames only on Android/dumpsys gfxinfo and physical iOS devices via xctrace, while the iOS simulator yields only JS-thread rAF rate. It omits whether a device/app must be connected first, what the returned metrics look like, and any cost or blocking behavior of the 'short window'.

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

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

Two sentences, front-loaded with the core action, and the platform caveat follows efficiently. Slight vagueness in 'short window' rather than a concrete default keeps it from being maximally crisp.

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

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

With no annotations, no output schema, and zero schema description coverage on three parameters, the description should compensate but doesn't. It covers platform data-quality caveats well yet leaves the agent without guidance on required setup (connected device, running app) or what the measurement returns.

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% for three parameters (app_id, device, duration_ms), and the description never explains any of them. 'Short window' loosely gestures at duration_ms but gives no units or default, and app_id/device semantics (target selection, whether device is required) are entirely undocumented.

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

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

States a specific verb and resource ('Measure frame timing for a short window'), which is clear on its own. It doesn't name which sibling to prefer over it (profile_renders, profile_js, sample_cpu all sound related to performance measurement), so an agent must infer differentiation from the names alone.

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 measurement use case but never says when to pick this over profile_renders, profile_js, or sample_cpu. The platform caveats tell the agent what data is trustworthy on Android vs the iOS simulator, which is useful context but not a when-to-use 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?

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether reading a job result is non-destructive, whether jobs are consumed or retained after collection, whether the call blocks until completion, or what happens if the job is still running. For a job-result retrieval tool, these are meaningful gaps.

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

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

Two short sentences with no wasted words. The primary purpose and the originating call are front-loaded, and the no-id listing behavior follows directly.

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

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

The tool is simple with one optional parameter and no output schema, so the description does not need to explain return values in detail. However, it leaves job lifecycle and result-availability semantics unstated, which matters for an agent deciding whether and how to poll for results. It is adequate but incomplete.

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

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

Schema description coverage is 100%, so the single id parameter is already well documented in the schema. The description repeats that omitting the id lists all jobs, but adds no syntax, format, or meaning beyond that. Baseline 3 is appropriate when the schema does the work.

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

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

The description states a specific verb and resource: it collects the result of a background job, and explicitly names the originating sibling call eval_js with background: true. It also distinguishes the no-id case as a listing operation, so an agent can identify the tool without opening the schema.

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

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

It gives clear context for when to use the tool: after starting a background job via eval_js (background: true). It also explains the no-id behavior. It does not explicitly state when not to use it or name alternatives, but the prerequisite condition is clear enough for correct selection.

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

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

With no annotations, the description carries the full burden; it does disclose useful behavior — center-coordinate semantics, that out-of-view elements are segregated as off-screen, and the default capture path. It says nothing about cost, permissions, freshness of the snapshot, or the shape of the returned data.

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

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

Three dense sentences with the core result (elements + coordinates) front-loaded and the optional modifiers following. No filler, though the parenthetical enumerations compress a lot of meaning into semicolons.

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?

Missing.

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

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

Schema coverage is 0% with 7 parameters, so the description has to compensate and only partly does: it explains search (matched against text/testID), type, at:{x,y}, and source (js/os/auto with default). It leaves match, case_sensitive, and device undocumented, so three of seven parameters remain opaque.

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

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

States a specific verb and resource: retrieves interactive on-screen elements with their center coordinates, plus off-screen elements listed separately. Clear enough to know what you get back, but it never distinguishes itself from siblings like get_component_tree, read_screen_text, or observe, which an agent must choose between.

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?

Offers usage patterns for the optional modes (filter by search terms, narrow by type, point query via at:{x,y}) and explains the source default, so the agent knows how to use the parameters. It gives no guidance on when to prefer this over the sibling tree/state/text tools.

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

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

With no annotations at all, the description carries the full burden and does disclose a non-obvious behavioral limit — only logs emitted after connect are captured — plus the reload_app remedy. It still omits return shape (fields, ordering), whether the buffer is capped, and whether the call blocks or polls.

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 compact sentences: purpose first, filtering second, and a caveat that earns its place because it prevents a wrong conclusion about missing cold-start logs. 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 tool with zero annotations, zero schema descriptions, and no output schema, the definition covers purpose and the capture-window caveat well but leaves the agent guessing about the return payload and the `limit` semantics. Adequate, not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for two of three params ('filter by level', 'search substring'), but says nothing about `limit` — neither default value nor whether it returns the newest or oldest N — and the schema gives that param no description either.

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

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

The description states a specific verb and resource — 'Recent console logs from the app' — plus what can be filtered. It is distinct from get_errors/get_network in substance, but it never names those siblings, so the agent must infer the boundary rather than being told.

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

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

It gives concrete usage context ('Filter by level and/or search substring') and an explicit alternative with a condition: use reload_app to catch cold-start output that predates connect. That is clear when-to-use guidance, though it lacks an exclusion pointing to get_errors when only errors are wanted.

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

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

With no annotations the description carries the full burden and does well: it discloses that the list view truncates query strings, that dev traffic is hidden by default, and that requests before connect are missed due to cold start. It implies a read-only capture but never states whether results persist or how they are ordered.

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

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

Four dense sentences, front-loaded with what the tool returns before the modifier mechanics. Every clause carries usable information; the only mild cost is that the truncation/dev-filter/cold-start notes are packed into one paragraph.

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 five-param capture tool with no annotations and no output schema, the description covers the behaviors an agent most needs (truncation, default hidden dev traffic, cold-start gap). The remaining gap is the undocumented limit/search semantics, which is minor given their conventional meaning.

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

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

Schema coverage is 0%, so the description must compensate. It explains detail, exclude and include_dev with concrete mechanics, but limit and search are left entirely unexplained in both schema and description, so compensation is partial.

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 first sentence gives a specific resource (recent in-app HTTP requests) that is clearly distinct from network-adjacent siblings like get_logs and get_errors. It doesn't explicitly name a sibling to differentiate against, 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?

It gives concrete conditional guidance: pass detail:<seq> to get full URLs and bodies, include_dev:true reveals dev-tooling traffic, exclude:[...] drops by substring. That tells the agent how to shape the call, though it never states when to prefer this tool over get_logs or get_errors.

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

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

With no annotations, the description carries the full burden and discloses depth-first summarization to keep JSON valid, default depth, resolved/failedAt/availableKeys error semantics for bad paths, and a store-global prerequisite. It does not explicitly state read-only/no side effects or what happens if the store is not registered beyond 'reliable access'.

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

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

Four sentences, front-loaded with purpose, then parameters, resolution behavior, and setup. Each sentence adds useful information with no fluff.

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

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

Given no annotations and no output schema, the description is fairly complete: purpose, parameter usage, error-resolution semantics, and store setup. It still leaves some return-shape and side-effect details implicit, so it is not fully 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?

Schema description coverage is 0%, so the description must compensate. It explains both parameters: optional dot-path with example 'user.name' and depth default 3. It does not restate schema bounds (maximum 8, exclusiveMinimum 0), but adds meaningful semantics beyond the raw schema.

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

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

States a specific verb and resource: 'Read app store state (Redux/Zustand/custom)' with depth-first summarization. It does not explicitly contrast with sibling tools like check_state or observe, so the purpose is clear but sibling differentiation is absent.

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?

Implies usage for reading Redux/Zustand/custom stores and includes a setup prerequisite ('Assign your store to globalThis.__RNE_STORES__'). It gives no explicit when-to-use/when-not guidance or alternatives such as check_state, observe, or eval_js.

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

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

No annotations are provided, so the description carries the full behavioral burden. It identifies target device and bundle formats, but does not disclose whether installation overwrites an existing app, preserves app data, requires signing, or what happens on failure.

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

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

The definition is a single front-loaded sentence with no filler. It is efficient, though somewhat under-informative for a mutation 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 a mutation tool with no annotations, no output schema, and low schema coverage, the description is incomplete. It covers bundle formats but not prerequisites, side effects, or device selection semantics.

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

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

Schema description coverage is 0%, so the description must compensate. It usefully explains the app_path file formats, but it never clarifies the optional device parameter: whether it takes an ID, name, or defaults to the active device.

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

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

The description states a specific verb and resource: install an app bundle on the active device. It also names accepted platform-specific bundle types (.app/.ipa/.apk), though it does not explicitly distinguish itself from siblings like launch_app or reload_app.

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

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

It implies the basic use case but gives no guidance on when to choose install_app over launch_app or reload_app, and it omits prerequisites such as a connected or booted device.

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

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

With no annotations, the description carries the full burden. It usefully discloses that env is iOS-only and that terminate_running restarts a running app, but says nothing about error behavior (e.g. app not installed), whether the call waits for launch to complete, or whether it foregrounds an already-running app.

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

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

Two tight sentences, front-loaded with the core action and identifier format, then the optional behaviors. Almost no waste; only the unexplained device parameter leaves something missing.

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 mutation tool with no annotations and no output schema, the description covers the main action and two optional parameters but omits the device parameter and any launch-failure or post-condition behavior. Adequate but with 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?

Schema coverage is 0%, so the description must compensate. It explains terminate_running, env (including the iOS-only restriction absent from the schema), and the app_id format, but the device parameter is never mentioned despite the schema exposing it.

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

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

States a specific verb (launch) and resource (an app), and clarifies the identifier format per platform (bundle id on iOS / package name on Android). It does not explicitly distinguish itself from siblings like install_app or reload_app, but the action is unambiguous.

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

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

Usage is implied: launch an app on the active device. There is no explicit guidance on when to use this versus install_app, reload_app, or open_url, nor any stated prerequisite such as the app needing to be installed first.

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

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

With no annotations, the description carries the full burden, and it does disclose one useful trait beyond the name: booted devices are marked. It says nothing about whether the call is read-only in effect, whether it starts or scans for devices, latency, or how many devices are returned.

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

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

A single short sentence, front-loaded with the verb and scope, with the useful "booted ones are marked" detail appended. No filler sentences.

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

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

For a zero-parameter lister with no output schema, the description nearly suffices: it states what is listed and that boot status is flagged. It omits the return shape (device identifiers/names) that an agent needs to feed connect or install_app, which is the main remaining gap.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to explain; the baseline of 4 applies. The description correctly implies the tool is unfiltered and returns all devices.

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

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

Names a specific verb and resource ("List available iOS simulators and Android devices") and adds the platform scope, so the agent knows what will be enumerated. It does not differentiate from the sibling list_targets, so the agent cannot tell at a glance which listing tool to pick.

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

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

Usage is only implied: an agent can infer this is a discovery step before connect/install_app/open_simulator, but nothing says when to use it or when to prefer list_targets or ping instead. No exclusions or prerequisites are given.

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

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

No annotations, so the description carries the burden. It usefully warns that stale pages from earlier reloads appear in results — a genuine behavioral caveat that prevents the agent from assuming duplicates are bugs. However, it says nothing about failure modes when Metro is unreachable, ordering, or whether the call is cheap/safe to repeat.

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

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

Two sentences, front-loaded with the action, with the parenthetical carrying only genuinely clarifying content. Nothing is redundant and nothing needs trimming.

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 does the important work of explaining what comes back (targets, including several per device, and a target_id to feed connect). Missing only the preconditions for calling it and any hint of the result shape beyond target_id.

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

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

Zero parameters, so the baseline is 4; the schema has nothing to explain. The mention of target_id is not a parameter but an output-field hint, which adds value in the absence of an output 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?

Specific verb+resource ('List every debuggable React Native target Metro exposes') with a clarifying parenthetical that defines what a target is and why one device can yield several. It implicitly distinguishes itself from list_devices by noting targets live behind Metro, though it never names that sibling explicitly.

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

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

'Pass a target_id to connect' establishes the downstream relationship to the connect tool, which is real routing guidance. But there is no explicit when-to-use or prerequisite statement (e.g., must Metro already be reachable? call list_devices first?), leaving the agent to infer the workflow.

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

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

No annotations are provided, so the description carries the full burden and does well: it discloses that no app-side setup is needed, that the container ref is cached on globalThis.__RNE_NAV__ until reload, that mutating actions report the resulting stack, and that unknown routes surface react-navigation's own error. It omits any note on reversibility or permissions for reset, which keeps it from a 5.

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

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

Dense but front-loaded: the core purpose comes first, then per-action semantics, then the implementation caveat. Nearly every sentence earns its place; only the react-navigation error-message detail is borderline padding.

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

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

For a stateful, multi-action navigation tool with no output schema and 0% parameter coverage, the description explains behavior well but leaves four of five parameters unexplained, so an agent could still misuse count, state, or params on first 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?

Schema description coverage is 0%, so the description should compensate. It thoroughly explains the action enum, but name, params, state, and count (max 50) are never described — the agent must infer that count bounds pop/back, that state feeds reset, and that params are route params.

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

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

States a specific verb and resource: 'Read or drive react-navigation (and Expo Router) from outside the app.' It then enumerates every action's effect, so the agent knows exactly what the tool is for and how each action differs from the others.

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 distinguishes push vs navigate ('push always adds a new card, navigate reuses an existing one') and groups the unwind actions, giving clear when-to-use guidance per action. It doesn't say when to pick this over UI siblings like tap or observe, so it stops short of a 5.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it does useful work: "Sections are independent — one failing does not lose the rest" tells the agent that partial results are a normal outcome rather than a hard error. It does not mention that the tool is read-only, the cost or latency of capturing a full snapshot, or what the default device is when the device parameter is omitted.

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

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

Two sentences, no filler, with the payload description front-loaded and the routing preference and failure-tolerant behavior in the second. Every clause adds information an agent needs.

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

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

There is no output schema and no annotations, so the description must explain what the agent gets back, and it only names the four sections without describing their shape or size. Combined with the unexplained parameters, an agent knows when to call this but not how to configure it or what the payload will look like.

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 all four parameters (device, source, full_res, screenshot) are undocumented in both the schema and the description. The words "screenshot" and "full" appear in prose, but the description never explains what these flags do, what the js/os/auto source enum means, or what the defaults are.

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?

"One-shot snapshot of the screen" states a specific verb+resource, then enumerates exactly what is bundled (screenshot, interactive elements, recent errors, recent logs). This is enough to distinguish it from the sibling tools screenshot, get_layout, and get_logs without opening any schema.

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

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

"Prefer this over separate screenshot/get_layout/get_logs calls" gives an explicit routing rule with the alternatives named, which is exactly the guidance an agent needs. It stops short of saying when this tool should NOT be used, for example when only logs are needed or full-resolution fidelity is required.

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

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

With no annotations, the description carries the full burden. It discloses the macOS-only constraint, which is real value, but says nothing about whether the call is idempotent when the simulator is already running, whether it blocks until ready, or whether it affects existing sessions.

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

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

A single short sentence with the platform caveat wrapped in parentheses — front-loaded and with no wasted words.

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 the description is nearly sufficient, but lacking annotations it should still say what state the simulator is left in and whether re-invocation is safe.

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 baseline of 4 applies; there is no parameter semantics to clarify or omit.

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

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

States a specific verb and resource ('Open the iOS Simulator app') and adds a platform qualifier, so an agent can tell it is not launch_app or open_url. It does not explicitly name those siblings, so it stops short of a 5.

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

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

No statement of when to reach for this versus launching an app or navigating to a URL, and no prerequisites (e.g. that a device may need to be booted first) are given. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden, and it does disclose a real behavioral trait: it delivers no touch event, so it is immune to slow touch delivery. It omits other important behavior such as what happens on an invalid or unhandled URL, whether the target app must be installed, and what the call 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?

Two sentences, front-loaded with the action and its input form, followed by a performance rationale. Every clause adds usable information and nothing is padded.

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

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

For a simple two-parameter tool with no output schema, this covers purpose, input form, and a genuine cost/performance consideration. The remaining gaps, device identification and error/return behavior, are minor but non-trivial since no output schema exists to fill them in.

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

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

Schema coverage is 0%, so the description must compensate. It usefully illustrates the 'url' format with two concrete schemes and 'active device' hints that 'device' defaults, but it never explains how the 'device' parameter is identified or formatted, leaving half the parameters undocumented.

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

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

States a specific verb (open) and resource (deeplink or universal link) with concrete URL examples (myapp://screen, https://…), making the input shape immediately obvious. It does not explicitly distinguish itself from the related sibling 'navigate', though the 'cheapest way to reach a screen' phrasing hints at that trade-off.

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 'usually the cheapest way to reach a screen' remark implies when to prefer this over touch-driven tools like tap, but no alternative is named and no when-not condition is given. The agent must infer the decision rule rather than being routed explicitly.

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

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

No annotations are provided, so the description carries the full burden; it does disclose the return payload ('pong'), which is the key behavioral fact for a no-argument read-only probe. It omits what happens on failure (error vs. alternate string) and whether any side effects exist.

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

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

Two terse sentences, zero filler, with the core purpose front-loaded and the return value immediately after.

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 trivial parameterless probe with no output schema, the description covers what it does and what it returns. The only gap is failure behavior, which is minor but would help an agent interpret a non-'pong' result.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing further the description could reasonably add on this dimension.

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

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

States a specific action (health check) and its exact return value ('pong'), which immediately distinguishes it from functional siblings like get_state or check_state. It does not explicitly contrast itself with nearby tools, but the purpose is unambiguous.

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

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

Usage is only implied: an agent can infer this is for verifying connectivity before other calls, but the description never says when to use it or what to do with the result. No alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries the full burden and does well: it discloses that 'js' bypasses the OS entirely by invoking the navigation container's goBack(), that 'os' degrades to a hardware key or edge swipe depending on platform, and that 'enter' fires onSubmitEditing without the OS keyboard. It omits failure behavior (e.g., what happens if no navigation container exists) and the role of the `device` parameter.

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

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

The core action is front-loaded and every clause about back/home/enter earns its place by disambiguating behavior. The prose is dense with parenthetical asides and em-dashes, which slightly impedes scanning but does not waste words.

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

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

For a tool with no annotations, no output schema, and a nested object parameter, the description supplies most of what an agent needs: key semantics, strategy selection, and field targeting. The remaining gaps are the undocumented `device` parameter and the absence of any statement about return values or error 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?

Schema description coverage is 0%, so the description must compensate, and it does for three of four parameters: it defines the semantics of each `key` value, the two `via` strategies plus the implicit default, and what `into` matches (label/testID/placeholder) when multiple fields are present. The `device` parameter is completely undiscussed, and the 'auto' enum value is never named.

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

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

States a specific verb and resource ('Press a hardware key') and then enumerates the three supported keys with their distinct behaviors. This is clearly distinguishable from siblings like tap, swipe, or navigate, which perform touch/gesture or route-level actions.

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

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

Explicitly guides the choice of `via`: 'js' is tried first by default and calls goBack() without touch, 'os' uses the hardware key or an edge swipe, and 'home' is OS-only. It also explains when to pass `into` for 'enter'. It stops short of telling the agent when to prefer this tool over navigate or tap in a navigation flow.

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

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

No annotations are provided, so the description carries the full burden and does a solid job: it discloses that a raw .cpuprofile is written to disk, that it can be loaded in Chrome DevTools, that symbolication is best-effort ('through Metro when it can'), and that sampling is bounded by a window. It stops short of saying whether the call blocks the app, what its overhead is, or what happens when symbolication or the device connection fails.

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

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

Three tight sentences: capability and output first, artifact/DevTools second, capture-window advice last. No sentence is filler — even the parenthetical 'or leave it alone' resolves a real operator question.

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 steps up by enumerating the report contents and the on-disk artifact. It leaves a modest gap around blocking behavior, failure modes (no Metro, device disconnect), and what the summary looks like when save=false.

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% and each parameter already documents its default, bounds, and even Hermes' tendency to ignore sampling_interval_us, so the description can safely defer. It adds only the implicit link between duration_ms and 'the window' and no syntax or behavior 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 gives a specific verb and resource ('Record a Hermes CPU profile') and even previews the output (busy/idle/GC split, top self-time and inclusive-time tables). It never names the closely related siblings sample_cpu or profile_renders, so the agent has to infer the distinction from the 'JS thread' phrasing rather than being told outright.

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?

'Drive the app (or leave it alone) while this runs — the profile covers whatever happens during the window' is genuinely useful operating guidance for the capture window. But there is no explicit when-to-use/when-not or routing to alternatives such as sample_cpu (process-level CPU) or profile_renders (render profiling), which is the main ambiguity an agent would face.

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 does well: it names the React DevTools global hook, restricts to dev builds, explains subtree pruning and its cost model, and warns that nothing re-renders on its own. It omits lifecycle details such as whether the hook stays installed after the window or must be removed, which matters for a tool that mutates global 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 front-loaded sentences: capability first, cost/constraint second, how-to-drive-it third. Dense with zero filler, and each sentence carries distinct 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?

No output schema exists, yet the description still tells the agent what comes back (per-component render counts, durations, initiating update) and points to get_job for collection. Only gap is post-window behavior of the installed hook.

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

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

Schema coverage is 100%, so all four parameters (top, label, background, duration_ms) are already documented in the schema with defaults and maxima. The description adds the background/get_job workflow context but no new semantics for top, label, or duration beyond what the schema states. Baseline 3 applies.

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

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

Opens with a specific verb and resource ('Count React re-renders over a window') and enumerates the exact outputs: components rendered, counts, time spent, and the update that started each commit. That is specific enough to separate it from siblings like profile_js or get_fps without reading 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?

Gives concrete operating instructions: drive the app during the window, use background: true plus tap/swipe, then get_job to collect. It never explicitly says when to prefer this over profile_js or sample_cpu, so it stops short of full alternative routing.

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

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

No annotations are provided, so the description carries the full burden and does: it discloses the OCR engine (Apple Vision), that it runs on-host, the macOS-only platform constraint, and a first-call latency cost (~10-30s helper compile, then cached). It also explains the return line format and the [tree] marker semantics — none of which any structured field provides.

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?

Dense but front-loaded: purpose first, then differentiators, then output format, then optional params, then platform/latency caveats. Every sentence carries information an agent needs — no filler and no restatement of the name.

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

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

There is no output schema, and the description compensates by specifying the exact line format (`<text> @x,y` in tap units) and the [tree] marker. Combined with platform limits, cold-start latency and parameter defaults, an agent has everything needed to call and interpret this tool.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for three of four params: search is substring/case-insensitive, languages takes codes like ["de","en"] and defaults to auto-detect, compare_tree defaults true. The `device` parameter is never mentioned, leaving one of four params undocumented in both schema and prose.

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

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

States a specific verb+resource ("Read the visible text off the screen with on-host OCR") and immediately scopes it against siblings: it sees text the layout tree cannot (images, canvases, WebViews, native dialogs). An agent can distinguish this from get_component_tree, get_layout and screenshot without opening any schema.

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

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

Gives explicit when-to-use (works without a Metro connection; text the layout tree can't see), and explicit routing rules for interpreting results: lines marked [tree] should be handled with tap {text}, OCR boxes with tap {x,y}. Alternatives are named, not 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 present, so the description carries the full burden. It discloses real traits (single concurrent recording, Android's 3-minute cap, codec being iOS-only) but leaves out permissions, where the file lands / how to retrieve it, and what output_path means.

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

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

Four terse sentences, front-loaded with the core action and constraint; each clause (stop tool, duration cap, codec platform note) carries information the agent needs.

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

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

Covers concurrency, platform limits, and how to stop, but with 3 undocumented params, no output schema, and no annotations, it should also explain output_path and device to be truly complete.

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

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

Schema coverage is 0%, so the description must compensate, yet it only clarifies codec ('applies to iOS only'). device and output_path get no explanation of format, defaults, or effect, and codec's enum values already live in 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?

Specific verb+resource ('Start a screen recording') with scope ('one at a time'), and it explicitly names the sibling used to stop it. An agent can distinguish this from other capture tools without opening the schema.

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

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

Gives the operating constraint (one at a time) and routes the agent to stop_recording to end it, plus platform-specific constraints. It does not discuss when to prefer this over screenshot, keeping it just short of explicit alternatives reasoning.

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 does useful work by disclosing that the tool waits for the new runtime and captures cold-start logs/network on the next run. It omits important side effects such as whether current app state is lost or whether this behaves like a restart.

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 a useful parenthetical and no wasted words. The key action and the blocking behavior are immediately clear.

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 action with no annotations and no output schema, the description covers the core operation and the wait behavior. It is not fully complete because it does not disclose whether reloading resets app state or other destructive side effects.

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 baseline is 4. There is nothing schema-related for the description to compensate for.

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

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

States a specific verb ('Reload') and resource ('the JS bundle') and adds the effect of waiting for a new runtime. It is clearly distinct from launch_app/install_app, though it does not explicitly name those siblings.

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

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

The parenthetical implies a use case: capturing cold-start logs/network on the next run. However, it gives no explicit when-not guidance or comparison with siblings like launch_app or install_app.

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, so the description carries the burden, and it discloses key runtime semantics: aborts on the first failure or app error, and returns an observe snapshot at the stop point. It also notes that each report line names the input path used. It does not state whether steps already executed before the abort remain applied to the app state (no rollback semantics), which is the main missing behavioral fact for a mutating batch tool.

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

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

Three sentences, front-loaded with the purpose and the alternative, with no filler. The middle clause about fiber-tree dispatch and per-step path naming partly duplicates the via enum description already in the schema, which is minor redundancy but keeps it from a 5.

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, the description does cover the return behavior (stop-point observe snapshot, per-step report lines), which is the right call. But for a tool whose required parameter is an array of untyped step objects, the agent is left without the step vocabulary at the payload level (what fields tap/type/swipe/wait_for/expect take), so it cannot reliably construct a multi-step flow from this description alone.

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 core required parameter, steps, has an unstructured item schema (additionalProperties: {}), and the description compensates with a list of step kinds and a short example, which is real added meaning. However, via and observe already have detailed enum descriptions in the schema, so the description mostly restates them rather than adding new semantics, and the payload shape of each step kind remains undefined.

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

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

States a specific verb and resource — 'Run a sequence of UI steps server-side in one call' — and enumerates the supported step kinds (tap/type/swipe/wait_for/expect/expect_not/eval). It explicitly contrasts itself with the sibling tools tap and observe, so an agent can pick it without opening the schema.

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

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

Gives a clear selection rule: 'Prefer this over many separate tap/observe calls,' naming the alternatives directly. It also explains the via:'js' tradeoff as the reason to batch. It stops short of stating when NOT to use it (e.g. a single interactive tap you want to inspect step by step), so it is strong but not fully exhaustive.

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

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

With no annotations, the description carries the full burden and does disclose valuable platform-specific behavior: macOS `sample` with native call-graph frames on iOS simulator versus `top -H` giving only per-thread %CPU on Android. It also implies a short fixed sampling window. However, it omits prerequisites (app running, permissions), failure modes on unsupported platforms, and whether sampling blocks other calls.

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

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

Two sentences, front-loaded with the purpose and outcome, followed by the platform-specific mechanism. No filler, and the em-dash structure keeps the hot-thread enumeration scannable.

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-annotation, no-output-schema tool, the description does well on explaining what comes back and how it differs by platform, but it leaves the parameter surface and prerequisites undocumented, which is significant given three optional parameters at 0% schema coverage.

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

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

Schema coverage is 0%, so the description must compensate for all three parameters, yet it never names app_id, device, or duration_s. 'For a few seconds' loosely hints at a duration and the platform branches hint at device, but app_id is entirely unexplained and no defaults or accepted values are given for a tool where every parameter is optional.

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

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

States a specific verb (profile) and resource (running app's threads) with the concrete outcome: identifying the hot thread among UI/main, JS, or other. This clearly distinguishes it from siblings like profile_js and profile_renders, which target JS work or renders rather than CPU-per-thread.

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

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

Usage is implied by the outcome ('report which one is hot'), but the description never says when to pick this over profile_js or profile_renders, nor what prerequisites exist (does the app need to be running/foregrounded?). The agent must infer the selection criteria.

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

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

With no annotations, the description carries the full burden and does real work: it discloses the 800px JPEG downscale default, the native PNG override, the actionable-error failure path when the image is too large, and that mask is iOS-only. It omits operational context such as permission or device prerequisites.

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

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

Two sentences, front-loaded with the core action, with the two modes laid out in a readable order. The second sentence is dense and slightly run-on, but every clause carries distinct 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?

No output schema and no annotations, yet the description states what is returned in both modes (inline image vs. file path) and the failure behavior, which is the key completeness requirement here. Only the undocumented `device` parameter keeps it from being fully self-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?

Schema description coverage is 0%, so the description must compensate, and it explains four of five parameters: output_path (save vs. inline), full_res (native PNG), format (png/jpeg), and mask (iOS-only). The `device` parameter is left entirely unexplained, which is the main remaining gap.

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

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

Opens with a specific verb and resource ('Capture the current screen') and immediately splits into two well-defined modes (inline return vs. file save). It is clear what the tool does, but it never names the obvious alternatives (record_video, read_screen_text) to sharpen the boundary.

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

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

Gives explicit conditions for the two main branches: 'Without output_path...' versus 'With output_path...', plus the full_res escape hatch for native resolution. It tells the agent how to choose a mode, but offers no guidance about when to reach for this tool instead of sibling capture/inspection tools.

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

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

With no annotations, the description carries the full burden and does well: it discloses the early-return short-circuit when the element is already visible, that os mode re-reads layout after each swipe and stops as soon as it appears, and that auto names its fallback reason. It omits failure behavior (what happens when the element is never found), interaction with max_swipes, and the return shape.

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

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

Front-loaded with the core purpose in one sentence, then the early-return rule, then the mode breakdown. Dense but every clause carries information; the semicolon-delimited mode list is efficient rather than padded.

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

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

For a 5-parameter action tool with no annotations and no output schema, the description covers the mechanism well but leaves element targeting, device selection, swipe budget, and the return/error contract entirely unaddressed. Adequate to call it, insufficient to call it correctly on the first try.

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% across 5 parameters, so the description must compensate. It thoroughly explains the `via` enum semantics, but says nothing about `text` vs `testID` (are they alternatives or combined? is one required?), `device`, or `max_swipes` — the latter is only obliquely implied by 're-reads the layout after each swipe'.

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

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

States a specific verb+resource ('Bring an off-screen element into view') and immediately separates itself from the sibling swipe/tap tools by noting js mode does 'no touch, no swipe'. An agent can tell this is the element-targeted scrolling tool, not a raw gesture tool, without opening any schema.

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

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

The description gives concrete mode-selection guidance: js asks the element's own scroll container, os swipes and re-reads layout, auto (default) tries js then falls back. It explains why you'd pick each mode, but never states when NOT to use this tool or when to prefer siblings like swipe/navigate 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?

No annotations exist, so the description carries the full burden. It does disclose the most important behavioral trait — that this bypasses the system permission alert — plus the app_id default to the connected app. It does not explain reversibility of 'reset', whether the target app must be installed/running, or what an invalid service does.

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

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

Three dense sentences with zero filler, and the core action leads. The long service enumerations consume most of the length but each entry is functionally necessary given the free-string schema.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the definition covers action, services, and one default but leaves the device parameter, reset semantics, and failure modes unexplained. Adequate to call correctly in the common case, incomplete at the edges.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it documents the valid service strings per platform (iOS vs Android lists differ), which the bare 'service: string' schema omits, and it explains the app_id default. The 'device' parameter and the semantics of 'reset' remain undocumented.

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

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

Opens with a specific verb triple (grant, revoke, reset) applied to a precise resource ('one privacy permission for an app'), and enumerates the valid services per platform. No sibling in the list manipulates permissions, so the agent can immediately tell this apart from tap/launch_app/observe.

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 'so the system alert never appears' gives a concrete decision context: use this instead of letting the OS permission dialog surface. It does not state exclusions (e.g. what to do if the app is not installed, or when to prefer manual UI handling), so it stops short of a 5.

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

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

With no annotations, the description carries the full burden; it does disclose the output (file path), which is helpful since there is no output schema. However, it omits whether the file is finalized/saved at a default location, whether the operation is idempotent, and what error occurs when no recording is running.

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

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

A single front-loaded sentence with zero filler; the action and its result are stated immediately.

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 stop/teardown tool, action plus return value is nearly everything an agent needs. The only real gap is failure behavior when no recording is active, which is minor but non-zero.

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 description has nothing to compensate for and correctly stays silent on inputs. Baseline 4 applies for a parameterless tool.

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

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

States a specific verb and resource ('Stop the active screen recording') and names the artifact produced (file path). It is clearly distinguishable from siblings like record_video, though it never names that sibling explicitly.

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

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

The phrase 'active screen recording' implies a precondition (a recording must be in progress), but the description never states what happens if none is active, nor does it point to record_video as the way to start one. Usage is inferable but not explicit.

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

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

With no annotations, the description carries the full burden and does well: it discloses that js mode performs a container scroll with no touch, os mode is a real device gesture, and auto tries js first and reports the fallback reason. It does not cover permissions, return values, or what happens with missing parameters, but the core behavioral distinctions are unusually well explained.

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 two operating modes are front-loaded in the first sentence, and the delivery-path explanation follows efficiently. The second sentence is dense but every clause adds useful 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 an 8-parameter tool with zero required parameters, no annotations, and no output schema, the description leaves important gaps: it does not clarify that at least a direction or a full coordinate pair is needed, nor does it explain duration_ms or device. It is minimally viable for the core use cases but not complete.

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

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

Schema description coverage is 0% for 8 parameters, so the description must compensate. It meaningfully explains 'via' values and implies that direction and coordinate modes exist, but it does not clarify whether x1/y1/x2/y2 must be supplied together, what device selects, or what duration_ms controls.

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

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

States a specific verb (swipe) and two clear modes: by direction scaled to the screen, or between explicit coordinates. It is clear what the tool does, though it does not explicitly distinguish itself from the sibling scroll_to tool.

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?

Provides useful guidance on how to choose the 'via' delivery path (js vs os vs auto), including fallback behavior. However, it gives no guidance on when to use swipe instead of sibling tools like scroll_to or tap, and does not state 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, the description carries the burden and does well: it discloses the default delivery path ('default auto'), the two execution semantics (calling the component's own handler through the app runtime vs a real device touch), and what is returned (coordinates, path used, screen changes). It omits failure behavior, such as what happens when text/testID matches nothing or matches multiple elements.

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

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

Three tight sentences, front-loaded with the core action and targeting modes before the modifiers and the return contract. No filler or restated name.

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 7-parameter tool with no annotations and no output schema, the description covers the essential contract including return values and the default path. The remaining gaps are the undocumented 'device' parameter and ambiguous-selector/error handling, which an agent would need in 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?

Schema coverage is 0%, so the description must compensate and largely does: text, testID, x, y, duration_ms, and the via enum are all given meaning beyond their names. However, the 7th parameter 'device' is never mentioned, and the precedence between element selectors and coordinates (or whether x and y must be supplied together) is left unspecified.

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

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

States a specific verb and resource ('Tap an element') and enumerates the three targeting modes (text, testID, x+y coordinates), which cleanly separates it from siblings like swipe, type_text, and press_key. An agent can pick this tool without opening the schema.

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

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

It gives conditional guidance within the tool: duration_ms selects a long press, and via selects js vs os with an explicit 'auto' default. It does not name alternatives (e.g. when to prefer swipe or scroll_to instead), so exclusion guidance is absent.

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

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

With no annotations, the description carries the full burden and does it well: it explains the mechanism of each `via` mode, gives a timing figure (~1ms), states that verify defaults to true and fails loudly, and warns about positional keycodes being rewritten by non-ASCII host layouts. It omits the behavior of `submit` and `device`, which are behavioral as well as structural.

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

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

Front-loaded with the action, then field targeting, then strategy selection, then verification — a sensible order with no filler. The em-dash clauses are dense but each carries real information; the sentence on keyboard layouts is long but earns its place as a warning.

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 6-parameter tool with a nested targeting object, no output schema and no annotations, the description covers the hard parts (targeting ambiguity, mode choice, verification). The gap is `submit` and `device`, which an agent would have to infer from the bare schema.

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

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

Schema coverage is 0%, so the description must compensate. It meaningfully documents `into` (matching by testID, placeholder, accessibilityLabel), `via` with defaults, and `verify` with its default and failure mode, but `text`, `device` and `submit` are entirely unaddressed. It also refers to `accessibilityLabel` while the schema field is named `label`, creating a naming mismatch an agent must resolve.

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?

Opens with a specific verb and resource: 'Type text into a text input.' An agent can immediately separate this from tap, press_key or eval_js. It does not explicitly name a sibling to contrast with, so it stops short of a 5.

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

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

Gives concrete selection conditions: omit `into` only when a single input is on screen, and pick `js`/`os`/`auto` based on the tradeoff described. It lacks any guidance on when typing is not appropriate (e.g. use press_key for special keys) or ordering relative to tap/observe.

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