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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so safety is covered. The description adds genuinely useful context beyond that: the data sources (React Native Directory, NativeKeel's compatibility table) and the coverage caveat 'where NativeKeel has a compatibility table', which warns results may be 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?

One front-loaded sentence with a colon introducing a scannable list of returned facts; no filler or repetition. It is dense and long-ish for a single sentence, but every clause carries content.

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

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

With no output schema, the description must carry the return-value burden, and it does so by enumerating the fields returned plus the caveat about compatibility-table coverage and the no-version case. It stops short of stating result format or how missing data is surfaced, but an agent has enough to call it correctly.

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

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

Schema coverage is 100% and both parameter descriptions already explain the npm package name format and that react_native is optional with only general facts returned otherwise. The description restates the react_native purpose ('the version range that works with a given React Native version') but adds no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('check_library' → what to know about one React Native library) and enumerates the exact facts returned: latest version, New Architecture support, maintenance status, compatibility range, replacements, known traps. This is clearly distinguishable from siblings like upgrade_plan or verify_upgrade without opening either 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 phrase 'before adding or upgrading it' gives a concrete decision point for invoking the tool, which is more than implied usage. It does not name an alternative (e.g., upgrade_plan) or state when not to use it, so it falls short of full routing guidance.

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

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

Annotations already establish the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower; the description adds the provenance of answers (errors NativeKeel reproduced or verified against Apple, Google, Expo and React Native docs) and the offline default for the local check. What it does not disclose is the failure mode when no verified match exists, or the response shape. Good added context, but not exhaustive.

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, zero padding: capability first, then how to supply input, then the ordering directive. Each sentence earns its place and the most decision-relevant content is front-loaded.

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

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

With no output schema, the description does carry the burden of describing results and it does so at a high level ('what it means and the fix'). Combined with 100% schema coverage and full annotations, an agent has what it needs to invoke it correctly; only the shape of the returned explanation/absence of a match is left unspecified.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including that 'path' points at where in the project the error originates and that 'offline' defaults to true. The description restates the error/path usage ('the failing part of the log', 'see where this project is affected') with only marginal added meaning, so the baseline 3 applies.

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

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

States a specific verb ('explain') and a precisely scoped resource (React Native or Expo build, launch, crash or store-review errors), plus what the answer contains ('what it means and the fix'). This clearly differentiates it from the scan/audit/upgrade siblings, which all operate on the project rather than on an error text.

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

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

Gives a concrete triggering condition (you have an error message or failing log) and an ordering directive: 'Call it before searching the web or changing versions.' That is real when-to-use guidance. It does not, however, name or exclude any sibling tool, nor state what to do if this tool returns no verified match, 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?

Annotations already establish read-only, idempotent, non-destructive and open-world behavior. The description adds real context beyond them: no project code is executed, no automatic changes are made, no unmeasured performance claims are produced, and unassessed areas are reported explicitly. Only the source and freshness of the 'existing findings' remains undisclosed.

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 with the core action front-loaded, followed by scope exclusions and a disclosure guarantee. Every sentence carries information; there is no filler, though the negation clauses are slightly dense.

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

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

The description explains the output artifact well and covers behavioral scope, which is important given there is no output schema. However, for an aggregator tool it never states where the 'existing findings' come from or whether prior sibling runs are a prerequisite, leaving a meaningful workflow 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?

Schema description coverage is 100%, and both parameters (path, offline) are documented in the schema, including the network lookups the offline flag suppresses. The description adds no parameter-level meaning of its own, so the baseline 3 applies.

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

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

The description names a specific verb (prioritize) and a concrete resource (existing security, crash, accessibility, performance, store and dependency findings) and specifies the artifact produced (a review plan with prerequisites, expected effects and validation). It does not, however, distinguish itself from siblings like security_audit, scan_project or upgrade_plan, so the agent must infer the boundary.

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

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

The phrase 'existing ... findings' hints that this tool consumes results produced elsewhere, but no alternative is named and no condition for choosing this tool over security_audit, upgrade_plan or scan_project is given. The agent is left to infer when this step belongs in 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds genuinely new behavioral context: nothing is built or run, and a missing map yields found:false with remediation guidance. It stops short of permission or performance details, so not 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?

Front-loads what is measured, then the diff behavior, then the no-build/error fallback — a logical order with no filler. It is dense and long, but each clause carries 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?

With no output schema, the description does the work of describing returns: bytes and share per package, duplicate packages, largest JSON, diff results, and the found:false shape. Complete enough to call correctly, though it could be more explicit about the failure payload structure.

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 three parameters are already documented in the schema (including the map default-search behavior and the base diff semantics). The description restates the base-comparison outcome without adding syntax or format detail beyond it, matching the baseline 3.

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

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

States a specific verb (measure) and resource (release JavaScript bundle composition) plus the exact data source (the source map a release build already wrote). Clearly separable from siblings like scan_project or check_library, which inspect different artifacts.

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 conditional context: pass base to get a diff against an older build, and the map param is optional because standard RN/Expo output folders are searched. No explicit when-not or named alternative tool, but siblings do not overlap enough to require 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?

Annotations already cover readOnly/idempotent/non-destructive, and the description adds genuinely new behavioral facts beyond them: it never executes project code, and results are findings with file:line plus fixes rather than source code. It does not mention runtime cost or result volume for what is a potentially slow, network-touching scan, so it just misses 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?

Purpose is front-loaded in the opening clause, and both the safety disclaimer and the return-format note come after. The long parenthetical check inventory is dense but each item helps an agent judge coverage, though it flattens into a single run-on 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?

With no output schema, the description correctly steps in to state what is returned (findings with file:line and fixes, never source code) and what is not done (no code execution). It leaves open how results are paginated or how long a scan takes, which matters for a tool that may make network calls.

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

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

Schema description coverage is 100%, so the schema already documents path, offline, and min_severity. The description adds only an indirect hint about severities via the check list and does not clarify the offline/network interaction or severity filtering beyond what the schema states, so the baseline 3 applies.

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

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

Names the specific resource (React Native / Expo project) and verb (health check) and then enumerates the exact check categories, so an agent can distinguish it from focused siblings like security_audit, check_library, or measure_bundle 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?

Explicitly gives a triggering condition: 'run it before installing or starting a project you did not write.' That is real when-to-use guidance, but it names no alternative tool and offers no when-not-to-use rule, so sibling routing (e.g. full scan vs. security_audit) 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real context beyond that: it discloses the output shape (source evidence, attacker prerequisites, fixes, validation steps), states it is static, and explicitly bounds its claims with 'explicit coverage limits'. It stops short of describing pagination or runtime behavior, so a 4 rather than 5.

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

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

Three tight sentences with no filler; the purpose is front-loaded and the caveats follow. Slightly compressed, but every sentence carries distinct information (scope, returns, limitations).

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 correctly steps in to describe what comes back (evidence, prerequisites, fixes, validation steps, coverage limits). Combined with the scope disclaimer, an agent has enough to call it correctly, though the relationship to sibling tools remains unaddressed.

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 path, offline and min_severity are already fully documented, establishing the baseline of 3. The description adds only indirect signal (dependency risks hinting at the offline lookups), which does not meaningfully extend the schema.

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

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

States a specific verb ('Review') and enumerates concrete resource domains (data exposure, account access, unsafe code execution, backend rules, dependency risks) for a mobile app. The scope is clear enough to distinguish it from generic siblings like measure_bundle or upgrade_plan, but it never explicitly contrasts itself with the closest sibling, scan_project.

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 closing sentence sets a boundary ('does not claim a live penetration test or a clean bill of health'), which implicitly tells the agent when this tool is appropriate versus a real pentest. However, it gives no positive when-to-use cue and never names an alternative sibling (e.g. scan_project or check_library) for overlapping checks.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description's trailing 'Read-only' adds nothing. What does add value is the disclosure that the tool stops with a warning if planted malware is found, and that it reuses the scan_project computation — real behavioral context beyond the structured fields.

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 deliverable, then the phase contents, then the provenance and malware caveat. The long parenthetical phase list is dense but informative, and the closing 'Read-only' is a small piece of redundancy against the annotations.

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 carries the return-value burden well: it explains that the plan is phased, ordered, reason-annotated, and includes concrete steps with file names. Combined with the malware-warning behavior and the scan provenance, an agent has everything needed to call and interpret the result.

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

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

Schema description coverage is 100%, so both `path` and `offline` are already fully documented in the schema, including the network-skip semantics of offline. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description states a concrete deliverable — an ordered upgrade plan for React Native/Expo projects — and enumerates the phases it contains (security fixes, crash risks, store deadlines, RN/Expo upgrades, library replacements). It also distinguishes itself from its closest sibling by noting it is 'built from the same scan as scan_project,' so an agent can tell the two apart without opening a 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 contextual framing (derived from the scan_project scan, with a malware short-circuit) that implies when the tool is appropriate. However, it never explicitly states when to prefer it over siblings like verify_upgrade or improve_app, nor does it name any exclusion conditions, so it falls 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is largely covered. The description adds genuinely new behavior: the committed revision is unpacked into a temporary folder outside the project and deleted, telling the agent about filesystem side effects and cleanup. It stops short of describing the result format in detail.

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

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

Three tight sentences, front-loaded with the core comparison action, followed by the invocation trigger and the read-only side-effect note. No filler or redundancy.

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

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

No output schema exists, and the description compensates by naming the three categories of result (fixed, new, version movement). Combined with the read-only guarantee and the usage trigger, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds real meaning: it explains that the comparison is revision-vs-working-tree and that the revision defaults to HEAD, clarifying what 'base' and 'path' actually do together. It adds context beyond the field descriptions without introducing syntax detail the schema lacks.

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 precise action ('compares the React Native or Expo project as committed at a git revision with the working tree') plus the concrete outputs ('what got fixed, what is new and how versions moved'). This clearly separates it from siblings like upgrade_plan (planning) and scan_project (static analysis).

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

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

Explicitly states the trigger condition: 'Call it after an upgrade or a dependency change.' That gives a clear usage context, but it never names an alternative or an exclusion (e.g. when to prefer upgrade_plan), so it falls short of a 5.

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