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

No annotations are supplied, so the description carries the full burden and largely drops it. It never says whether results are persisted (the 'store' param defaults to true, implying a side effect), whether it operates on a live page or requires navigation, whether it can mutate page state, or what the response looks like. 'Run ... checks' gives no hint that this has any write/storage behavior at all.

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

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

The single sentence is front-loaded and contains no filler, but it is undersized for a four-parameter, four-mode tool. Brevity here comes at the cost of specification rather than from efficiency.

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

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

With no output schema, no annotations, and four parameters of which three are undocumented, an agent has to infer the return shape, persistence behavior, and mode selection entirely from enum values. The description leaves the majority of what an agent needs unstated.

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

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

Schema description coverage is 25% — only the required 'action' param is documented, and its description is a restatement of the field name. The description adds nothing about 'store' (default true, clearly a side-effect toggle), 'tabId' (default 'active'), or 'standard' (which WCAG level applies). With coverage this low, the description was expected to compensate and does not.

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 domain (accessibility) and a verb (run audits/checks), which is more than a tautology. However, the tool actually exposes four distinct modes (audit, get_tree, check_keyboard, check_contrast) and the description covers only the audit/check subset, never mentioning the tree-dump capability. It also does nothing to separate this from near-siblings such as fileforge_audit_action or fileforge_eye_action.

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

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

There is no guidance on when to pick this tool over fileforge_audit_action, fileforge_qa_testing, or fileforge_eye_action, nor on which action to choose for a given goal. An agent must guess the intended context 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?

No annotations are supplied, so the description carries the full disclosure burden and delivers almost none of it. It does not say whether discovery reads a live tab, whether results persist (`store` defaults to true), whether export writes files to disk, what permissions or browser state are required, or whether any operation is destructive. The only behavioral hint is the implicit read/export framing, which is not enough for a six-action multiplexer.

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

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

It is a single short sentence with no filler, which is structurally clean, but 'concise' here means under-specified rather than efficient. Twelve words are not an appropriate size for a tool with six actions and eight parameters, and no structure (action list, mode split) is offered to help the agent navigate.

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 high-complexity: six enum-driven actions, eight parameters including a nested object, no annotations, and no output schema. Against that, the description names two activities and nothing else, so an agent cannot determine what any action returns or which parameters matter for which action. Completeness is far below what the tool's complexity demands.

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 13% across 8 parameters, with only `action` carrying a (tautological) schema description. The text adds no meaning for `store`, `tabId`, `export`, `filter`, `groupBy`, `filename`, or `includeBodies`, and does not explain the nested `filter` object shape. With the schema largely bare, the description was the only place to compensate and does not.

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 verb pair and a resource ("Discover and export REST and GraphQL API calls"), so the domain is identifiable. However, the tool's `action` enum exposes six distinct operations (discover, get_graphql_operations, find_openapi_specs, export_curl, export_postman, generate_msw_mocks), and the description mentions only two of them. It also does not distinguish itself from the overlapping sibling `fileforge_export_action`, leaving the agent to guess which surface handles export.

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 statement of when to choose this tool over `fileforge_export_action`, `fileforge_devtools_action`, or `fileforge_scrape_action`, all of which plausibly touch network traffic. No prerequisites, no exclusion of scenarios, no indication of whether it requires an open browser tab or prior capture. The only usage signal is the verb 'discover/export'.

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 supplied, so the description carries the full burden. It implies a read-only inspection but never states that nothing is mutated, that it operates on a specific tab (the tabId parameter is never referenced), whether content script injection is required, or how it behaves on restricted pages. For a 6-action dispatch tool with zero annotation coverage, this is a substantial gap.

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

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

A single front-loaded sentence with no filler, which is good. But the noun list substitutes for specification — "framework-specific state" is vague and the phrase structure does no work beyond enumerating domain areas. It is concise without being informative.

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

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

With no output schema, no annotations, a six-way action enum, and 33% parameter coverage, the description should explain the per-action outputs and constraints. Instead it gives one enumeration sentence. An agent cannot tell from this description what detect_framework returns versus get_react_tree_hint, or how storage/route data is shaped.

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

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

Schema description coverage is only 33%, and the description adds nothing about any parameter. The action enum is well documented inside the schema itself, so that parameter is fine. However, tabId (default "active") and includeStateHints (default false) are undocumented in both schema and description, and the description does not compensate for that low coverage.

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

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

The description uses a specific verb ("Inspect") plus a concrete list of resources: framework, routing, client storage, feature flags, framework-specific state. This maps recognizably onto the six action enum values. It falls short of a 5 because it never mentions the action parameter or distinguishes this tool from close siblings such as fileforge_devtools_action or fileforge_runtime_action.

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 when-to-use or when-not-to-use guidance, and no mention of alternatives. In a family with 27 sibling tools including devtools, runtime, page_interaction, and qa_testing, the agent is left to infer that this tool is for framework/state introspection rather than general browsing or debugging. Usage is only implied by the resource list.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does not disclose permissions, side effects, destructive behavior, logging, crawl behavior, authentication needs, or output characteristics for the 12 actions, beyond a vague reference to 'legacy' actions.

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

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

The description is short and front-loads the primary action, which is useful. The trailing 'legacy route/content/policy/security/recommendation/comparison/export/summary actions' list is dense and somewhat cryptic, but it does not waste many 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?

Given a 28-parameter tool with 12 actions, no annotations, no output schema, and very low schema description coverage, the description is far too thin. It orients the agent toward query_audit as the main action, but leaves action selection, parameter usage, and behavioral expectations almost entirely undocumented.

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

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

There are 28 parameters with only 4% schema description coverage, and the description explains almost none of them. It briefly hints at GraphQL-style modules and presets, but gives no meaning for key, ref, url, text, query, store, tabId, routes, target, project, snapshot IDs, or the other parameters.

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

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

The description clearly identifies this as a unified audit tool and names query_audit as the primary action, with comparison and legacy audit actions also available. It is specific enough to distinguish an audit resource, but it does not explicitly differentiate this tool from sibling tools such as fileforge_report_action or fileforge_export_action.

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 states that query_audit is the primary action and that compare_audit_snapshots and legacy actions are also available, which gives implied usage priority. However, it does not explain when to select this tool over sibling audit/report/export tools, nor does it give conditions for choosing among the listed actions.

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 supplied, so the description carries the full behavioral burden. It never mentions that actions include destructive ones (close_tab, close_tabs_matching), that dryRun exists as a safety valve, that captures produce artifacts, or what permissions/contexts are required — all of which live only in terse schema fragments.

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 capability, then the routing hint — no filler. It is efficient, though the brevity is achieved partly by omitting information the tool actually 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?

For a nine-action, 26-parameter tool capable of closing tabs and capturing network/HAR data, with no annotations and no output schema, the description is severely underpowered. Critical facts — defaults, what each action requires, what is returned after a capture — are absent, leaving the agent to reverse-engineer behavior from the schema 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?

With 26 parameters and only 58% schema description coverage, the description should clarify which parameters bind to which action. Instead it names only four action values and adds no parameter meaning beyond the schema; the schema's own descriptions (preset, tabId, urlIncludes) do the real work here.

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

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

States a specific verb+resource pair: 'Control browser tabs and read browser state', and the second sentence enumerates the action families (query_context for reads; navigate/history/wait for control). It doesn't distinguish itself from close siblings like fileforge_page_interaction or fileforge_devtools_action, so an agent can't fully resolve overlap, but the tab-management scope is clear.

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

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

The description gives an intra-tool routing hint ('Use query_context to read state; navigate/history/wait for tab control'), which is genuinely useful for picking an action. It gives no guidance on when to prefer this tool over the ~25 sibling tools, and no mention of when not to use it or of prerequisites for the destructive actions.

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 supplied, so the description carries the full burden and largely drops it. It does not disclose that capture launches browser contexts (audit_routes explicitly uses hidden Chrome), that results are persisted to a project store (store defaults to true, a side effect), that large text/screenshots are produced, or what latency and permission requirements apply. Only the words "Capture" and "store" hint at reads plus writes.

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

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

It is a single front-loaded sentence with no filler, which satisfies brevity. However, the sentence is short through under-specification rather than discipline; at this level of tool complexity, the compression removes information an agent needs rather than tightening redundant wording.

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?

A 19-parameter tool spanning four substantial capture modes, with no annotations and no output schema, needs far more description than one sentence. Nothing explains the stored bundle format, the difference between modes, or the effect of the store/project parameters, leaving the definition incomplete for correct invocation.

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

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

Schema coverage is only 16% across 19 parameters, so the description is expected to compensate, and it does not. It mentions page/route/bug/article bundles, which weakly signals the action enum, but says nothing about url, tabId, project, store, timeoutMs, settleMs, domDepth, includeStorage, includeApiBodies, or the other undocumented options.

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 verb "Capture" and the nouns "page, route, bug, and article context bundles" loosely map to the four enum actions, so an agent can guess the general domain. But "context bundles" is jargon that never resolves to what is actually produced, and the description does not separate this tool from fileforge_devtools_action, fileforge_a11y_action, fileforge_perf_action, fileforge_api_action, or fileforge_audit_action, all of which overlap with pieces of the described bundles.

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 when-to-use or when-not-to-use guidance appears in the description. With 26 sibling tools, several of which cover page inspection, route auditing, accessibility, and performance, the agent is left to infer that this is the bundled alternative to the narrower single-purpose tools. The only routing hints live inside the action enum's schema text, not the description.

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 the most important safety traits: evaluate is 'guarded' with dryRun and blocked dangerous patterns unless allowDangerous=true, replay_request blocks non-idempotent methods unless allowUnsafeMethods=true, and export_har writes a HAR archive to disk. It omits session prerequisites, whether evaluate mutates the live page, whether a capture must be running for replay/export, and any cross-tab side effects or limits.

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

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

Two sentences, front-loaded with the primary action before the secondary families, with zero filler. The terseness is efficient though slightly under-specified for a fourteen-action multiplexer, which is a completeness issue rather than a verbosity one.

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?

This is a 19-parameter, 14-action multiplexer with no annotations, no output schema, and near-zero schema coverage, and the description is two lines. An agent cannot determine from the definition alone which combination of action, operation, preset, and session flags to send, or what the enumerated action list in the schema actually returns for each module.

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

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

Schema description coverage is only 5% across 19 parameters, so the description would need to compensate heavily and largely does not. It hints at the query/preset shape ('GraphQL-feel modules + presets') and names three guard flags (dryRun, allowDangerous, allowUnsafeMethods), but store, tabId, filter, levels, filename, overrides, requestId, captureForMs, includeBodies, autoStartSession, and stopAfterCapture are given no meaning anywhere outside their bare types.

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?

It names the resource (DevTools), the primary verb path (query_devtools) and enumerates the secondary families: session lifecycle, evaluate, replay_request, export_har, and legacy get_* reads. An agent can tell this is the DevTools multiplexer. It stops short of differentiating from DevTools-adjacent siblings such as fileforge_perf_action, fileforge_api_action, or fileforge_browser_action, so it is clear but not sibling-disambiguated.

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 'Primary action: query_devtools' plus labeling the get_* reads as 'legacy' implies a preferred path, which is useful routing signal. However there is no explicit when-to-use/when-not guidance, no statement of prerequisites (e.g., a session must be started before export_har), and no comparison against the many sibling *-action tools that also touch pages and network traffic.

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 supplied, so the description bears the full disclosure burden, yet it says nothing about where exported files are written, whether existing files are overwritten, what permissions or runtime state are required, or what the tool returns (file path, bytes, URL). For a tool that produces side-effecting file output, these are material omissions.

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 grammatical sentence with no filler, so nothing is wasted. But brevity here reads as under-specification rather than discipline: for a five-parameter, two-mode export tool, one sentence leaves the structure an agent needs unstated.

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, five parameters, and only 20% schema description coverage, the description is far too thin for the tool's complexity. The format enum (nine values) and the filename parameter are never mentioned, and the return behavior of an export operation is entirely 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 only 20% — just the action enum is documented. The description gestures at two parameters ('stored results' implies ref, 'SQL query output' implies query) but adds no meaning for ref, query, format, or filename beyond the bare names, so it does not compensate for the coverage gap.

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

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

States a specific verb (Export) and resources (stored results, SQL query output), which is enough to know roughly what the tool does. It does not, however, distinguish itself from siblings like fileforge_result_action or fileforge_sql_action, which cover adjacent ground, so an agent cannot tell from the description alone why it should pick this tool over those.

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 contains no when-to-use guidance, no exclusions, and no pointer to alternatives. The only routing information ('result' vs 'query') lives in the schema's action enum description, not in the tool description, so the agent must open the schema to learn the two modes.

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

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

With no annotations, the description carries the full behavioral burden, yet it says nothing about side effects, permissions needed, or logging. Notably, reveal_storage_value exposes a redacted secret and writes an audit log, and store defaults to true — none of that risk profile appears in the description.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though efficiency here partly reflects under-specification rather than disciplined editing.

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?

Seven parameters, no annotations, and no output schema demand more than one listing sentence. An agent gets no indication of which parameters apply to which action (e.g. tabId for inspect_injection, selectors, key for reveal_storage_value, area for inspect_storage), leaving invocation semantics guesswork.

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

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

Schema description coverage is only 14%, so the description must compensate for six undocumented parameters, and it does not: key, area, store, tabId, project, and selectors are never mentioned or explained. The only well-documented field (action) is described in the schema itself, not the description.

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

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

The description gives a specific verb pair ("Inspect and test") and a concrete resource set ("Chrome extension manifest, permissions, storage, service worker, injection, and errors"), which matches the action enum. It does not differentiate itself from sibling fileforge_* tools (e.g. devtools_action, runtime_action), which could plausibly overlap on service worker or error inspection.

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 when-to-use or when-not-to-use guidance is given; the sentence merely lists what can be inspected. Nothing tells an agent to prefer this over fileforge_devtools_action or fileforge_runtime_action, or that run_extension_check is the composite path while individual inspect_* actions are the granular ones (that contrast lives only in the schema).

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 valuable non-obvious behavior: locking a target auto-captures screenshots on errors, and tripwires 'fire silently' when conditions hit, which an agent could not infer from the schema. It says nothing about the statefulness of the watch session, permission/DevTools attachment constraints, or that the incognito actions open and destroy browser windows — a meaningful gap for a tool whose enum includes destructive cleanup actions.

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 capability and then the two operating modes (watch vs. lock/tripwire), with zero filler. The 'God's Eye' branding and 'Plant tripwires that fire silently' phrasing are colorful but still carry meaning. Slightly dense noun lists cost it a point.

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 15-parameter, 16-action tool with no annotations and no output schema, the overview should at least signal the action families (scan, watch, tripwire, incognito, report). The description covers roughly half of them and never explains what get_feed/get_report return, though the per-action enum text partially compensates.

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 15 parameters including the nested filter and tripwire objects with their match-string examples. The description adds only the all: true shorthand for start_watch, which duplicates the schema's own all description. Baseline 3 applies since the schema does the heavy lifting.

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 capability set: cross-tab monitoring of network traffic, console errors, JS exceptions, DOM mutations and WebSocket frames, plus target locking and tripwires. An agent can tell it is a live-instrumentation tool rather than a one-shot scrape. However, the prose covers only the watch/tripwire/lock surface and never mentions scan, incognito management, auto_track, watch_person, or get_report, so the tool's full scope is only discoverable via the action enum.

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 one concrete routing hint — watch 'chosen tabs, or every open tab with all: true' — which implies tabs/all are the two entry modes. But there is no explicit when-to-use versus siblings such as fileforge_devtools_action, fileforge_browser_action, or fileforge_perf_action, and no when-not guidance or prerequisites (e.g. that monitoring is session-based and stateful).

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 supplied, so the description carries the full behavioral burden, and it discloses almost nothing. It never mentions that operations persist artifacts locally (the 'store' default of true and the 'name' default of 'converted-data-uri' imply side effects), that fetching performs network requests, that page-scoped actions depend on an active browser tab, or what any operation returns. The words 'fetch' and 'convert' weakly imply network access and transformation, which is the only behavioral signal present.

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

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

One short, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity reflects under-specification rather than disciplined editing. Nothing is wasted, but very little is delivered.

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?

This is a 15-parameter, nine-action dispatcher with no annotations and no output schema, and the description is a single generic sentence. An agent would have to reverse-engineer action selection, required inputs per action, and side effects entirely from the schema. For a tool of this complexity the description is wholly inadequate.

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

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

Schema description coverage is only 27% across 15 parameters, so the description would need to compensate and it does not. The verbs loosely map onto several enum actions (fetch, parse, convert, inspect, decode), which adds marginal routing value, but parameters like run, store, limit, quality, project, and textPreviewLimit get no explanation anywhere in the description.

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

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

The description names concrete verbs (fetch, parse, convert, inspect, decode) and a resource domain (files and Data URIs), so the general area is identifiable. However, it bundles nine distinct operations into one clause and never states the scope boundary against the many file/page/API siblings such as fileforge_scrape_action or fileforge_api_action. An agent cannot tell from the description alone what this tool does that its siblings do not.

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 when-to-use guidance at all: no indication of when to prefer this over fileforge_api_action, fileforge_scrape_action, or fileforge_export_action, and no prerequisites such as needing a URL or Data URI. The only routing signal is the action enum embedded in the schema, which is structured data rather than description text. The verb list hints at usage contexts but never states one 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 supplied, so the description carries the full behavioral burden for a tool that can mutate state (save_page, store defaults to true, compact_result). It does not disclose persistence semantics, whether saved pages survive across sessions, whether diff requires a prior save, or what compact_result does to existing data. Only the bare fact that memory is "local" is added.

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

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

The single short sentence is efficient in the trivial sense but far too thin for an eight-action dispatcher, so the brevity reflects under-specification rather than good editing. There is no structure, no action-by-action breakdown, and nothing front-loaded to help an agent decide how to invoke it.

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 ten parameters, eight modes, no annotations, no output schema, and near-zero schema descriptions, this definition leaves an agent almost entirely unequipped. It cannot determine which parameters pair with which action, what a result slice is, or what any action 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 10% (only the action parameter has text, and it merely restates its name as "The memory action to perform"). With ten parameters, the description compensates for none of them: ref, url, query, project, store, limit, offset, tabId, and question are given no meaning, no defaults explanation, and no indication of which parameters apply to which action.

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

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

The description names three concrete domains (local page memory, diffing, result slicing), which gives a rough sense of the resource being managed. But the verb "manage" is vague and the eight enum actions (save_page, query, semantic_search, answer, find_previous_visit, diff_page, compact_result, get_result_slice) are never enumerated or explained, so an agent cannot tell what each mode actually does from the description 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?

There is no guidance on when to use this tool versus siblings such as fileforge_search_action, fileforge_result_action, or fileforge_page_interaction, and no guidance on how to choose among the eight actions. The mention of "diffing, and result slicing" hints at use cases but never states conditions for selecting them.

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 supplied, so the description carries the full burden, yet it discloses almost nothing: what 'local' storage means, whether create overwrites on duplicate titles, whether search is case-sensitive or matches body vs title, or whether results are paginated. For a three-mode tool with side effects (create writes data) this is a substantial disclosure gap.

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

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

One short front-loaded sentence with zero filler, which is structurally clean. However, the brevity here reads as under-specification rather than discipline, since nine parameters and three behaviors are compressed into eight words that do not earn enough coverage.

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 nine parameters, three distinct action modes, no annotations, and no output schema, the definition is far too thin. The description correctly enumerates the operations but omits parameter-to-action mapping, result shape, and pagination behavior that an agent needs 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 only 22%, so the description should compensate, but it adds no meaning for the eight undocumented parameters. Critically, it never says which parameters belong to which action (e.g., that query/limit/offset apply to search, tag/tags to filtering, body/title/url to create), leaving the agent to guess from names.

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

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

The description names three concrete verbs (create, list, search) against a specific resource (local notes), matching the action enum exactly, so an agent immediately knows the tool's scope. It does not differentiate itself from any sibling, though the domain-named siblings (task, sql, browser, etc.) make overlap unlikely.

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

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

There is no guidance on when to choose create vs list vs search, no prerequisites, and no mention of alternatives such as fileforge_memory_action or fileforge_search_action, which could plausibly be confused with note search. The only usage signal lives in the schema's action enum, not the description.

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 lists action names like click and fill but does not disclose which actions mutate page state, whether authentication or an active tab is required, what happens on failure, or how errors are surfaced.

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 wasted filler. The parenthetical action list is slightly noisy but still concise and efficiently structured.

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

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

For a 32-parameter, 27-action mega-tool with no annotations and no output schema, a one-sentence description is grossly inadequate. It does not explain action-specific parameters, side effects, return values, or how to choose among the many actions for correct invocation.

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

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

With 32 parameters and only 38% schema description coverage, the description should compensate by explaining key parameters. Instead it only repeats a few action enum values already in the schema and provides no meaning for mode, depth, store, tabId, timeoutMs, assertions, or the many other undocumented fields.

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 clear verb+resource ('Interact with the DOM, extract page info') and lists example actions like click, fill, assert, and smoke_test. However, it does not differentiate this broad tool from siblings such as fileforge_qa_testing or fileforge_browser_action, which also cover QA and browser interactions.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites mentioned, and no conditions for selecting among its many actions. The agent is left to infer usage entirely from the action enum.

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 supplied, so the description carries the full behavioral burden, and it does almost nothing. It doesn't say whether audits navigate a live browser, whether results are stored (the 'store' and 'project' params imply persistence) or what happens on timeout. 'Collect metrics' vaguely implies a read, but the storage side effects are 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?

One short sentence with no waste, but it's under-specified rather than concise. There's no front-loaded scope, required inputs, or output description to anchor the agent.

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 10-parameter tool with no annotations, no output schema, and 10% schema coverage, the description is far too thin. The agent lacks both the semantics of most inputs and any notion of what an audit returns or whether it mutates stored state.

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

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

Schema description coverage is only 10%, with 10 parameters and only the 'action' enum documented (and even that is circular: "The performance action to perform."). The description says nothing about url, store, project, settleMs, viewports, includeScreenshot, or the two network-idle timeouts, so an agent must guess at nine parameters' meaning and defaults.

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?

"Run performance audits and collect metrics" restates the title and name without adding specificity. It doesn't distinguish this tool from close siblings like fileforge_audit_action, fileforge_devtools_action, or fileforge_responsive_action, leaving an agent unable to tell which perf/audit 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?

There is no when-to-use, when-not-to-use, or alternative routing guidance at all. With 26 sibling tools including fileforge_audit_action and fileforge_a11y_action, the absence of any disambiguation is a real gap.

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

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

No annotations are supplied, so the description carries the full behavioral burden and largely does not meet it: nothing is said about side effects, whether "store" persists results, whether "watch_element" creates durable server-side state, what permissions or session state are required, or how long the default 30s timeout applies. Only the words "watches" and "capture_element_change" faintly hint that some actions are stateful rather than read-only.

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

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

It is a single short sentence with no filler, and the verb leads. However, the enumeration is unstructured and covers only four of the nine enum actions (console clean, network clean, forms, page boot, and capture_element_change are absent), so brevity comes at the cost of usefulness.

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 12 parameters, nine dispatchable actions, no annotations, and no output schema, one sentence is far from sufficient — the description should at minimum map actions to required parameters and state what each action returns or mutates. Nothing here lets an agent construct a valid non-trivial call without reading the raw JSON 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 description coverage is 8% — only "action" is documented, and that documentation ("The QA action to perform.") merely restates the field name. The description adds no meaning for any of the 12 parameters: which parameters each action requires (selector for watch_element, routes/baseUrl for check_routes, checks/viewports for run_frontend_check) is never explained and must be reverse-engineered from the enum.

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 ("Run") against concrete resources ("QA checks, smoke tests, element watches, route tests"), so an agent can tell this is frontend QA verification rather than, say, scraping or SQL. It offers no differentiation from closely overlapping siblings such as fileforge_audit_action, fileforge_a11y_action, fileforge_perf_action, or fileforge_visual_action.

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 when-to-use guidance, no mention of prerequisites (does a page need to be open or a devtools session attached?), and no routing toward or away from any of the 25 sibling tools. With nine possible actions and heavily overlapping QA-adjacent siblings, the agent is left to guess entirely.

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 supplied, so the description carries the full behavioral burden, yet it says nothing about side effects. It does not state whether bundles are written to disk, where they are stored, whether generation is expensive or rate-limited, or what permissions/extension state is required.

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, which is structurally clean. However, for a 6-parameter tool with two enums, this brevity crosses into under-specification rather than economy.

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 six parameters, two enums, no annotations, and no output schema, the description should explain at minimum what each action produces and how include/format/urls modify it. It does none of that, leaving the agent to guess at output shape and parameter behavior.

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

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

Schema description coverage is only 17%: solely 'action' is documented, and that documentation lives in the schema itself, so the description adds nothing beyond it. The five other parameters (urls, tabId, title, format, include) are unexplained anywhere — notably 'include' and 'urls', whose accepted values and interaction with the action modes are entirely 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?

The description states a specific verb ('Generate') and three concrete artifacts (bug reports, PR evidence bundles, debug bundles), which matches the action enum. It does not distinguish this tool from the many sibling *_action tools (e.g., fileforge_export_action, fileforge_result_action), so an agent cannot route between them from this text 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?

There is no guidance on when to choose this tool over fileforge_export_action, fileforge_result_action, or fileforge_devtools_action, all of which plausibly produce similar artifacts. No prerequisites, no exclusions, and no indication of when one action variant should be preferred over another.

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 and no output schema, the description carries the full behavioral burden. It doesn't say whether the scan is read-only, that a boolean store (default true) may persist results, that tabId defaults to the active tab, or what the results contain. "Scan" implies safety but "capture_matrix" and "store" imply capture/persistence, and the description never resolves that ambiguity.

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

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

It is one sentence with no wasted words, so it is concise. But the brevity is under-specification rather than efficiency: a single clause for a four-action, six-parameter dispatcher leaves the structure far too thin.

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?

A multi-action dispatcher with six parameters, only one-third schema coverage and no annotations or output schema needs a description that explains action selection and undocumented parameters. This one sentence does none of that, leaving the agent unable to distinguish actions or predict 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?

Only 33% of parameters are documented in the schema (action and widths), so url, store, tabId and checks depend entirely on the description — which explains none of them. "Across widths" weakly connects to the widths parameter, but the meaning of store, tabId and the checks enum values is absent from both places.

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

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

"Scan layout and find responsive issues across widths" gives a rough verb+resource (layout/responsive) that separates it from a11y, visual and perf siblings. However, the tool is a four-way dispatcher (scan_layout, find_overflow, find_overlaps, capture_matrix) and the description only covers the first two, leaving capture_matrix unexplained. That makes the stated purpose partial rather than specific.

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

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

There is no indication of when to pick this over fileforge_visual_action, fileforge_a11y_action or fileforge_perf_action, nor which of the four action values to choose for a given scenario. The closest thing to guidance is "across widths", which is a hint, not a usage rule.

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

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

With no annotations, the description carries the full behavioral burden and largely fails it. Only the word "stored" hints that results persist across calls; nothing is said about result lifetime, whether any mode mutates state, default limits (limit=100, offset=0), or what each mode returns for a 4-mode multiplexed 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?

One short sentence, front-loaded with the verbs and no filler. It is efficient, though its brevity stems from under-specification rather than disciplined editing.

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

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

For a six-parameter, four-mode multiplexed tool with no annotations and no output schema, a single sentence is inadequate. An agent cannot tell from the description what a 'get' returns versus a 'slice', how slice relates to offset/limit, or how search differs from list.

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 50%, and the description compensates for none of the gap. It adds no meaning beyond the schema for ref, query, limit, offset, or project, and merely echoes action names that the enum description already documents far more precisely (including 'newest first' and the searchable fields).

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

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

The description names the resource ("stored FileForge results") and four verb modes, so the general domain is clear. However, it is essentially a compressed restatement of the action enum values and does nothing to distinguish it from siblings like fileforge_search_action or fileforge_export_action, leaving an agent unsure which tool owns 'search' among 25 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?

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites (e.g. that a result ref must come from a prior FileForge call), and no routing to alternatives. The verb list implies contexts but never states any 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?

No annotations are supplied, so the description carries the full disclosure burden, and it discloses essentially nothing: no indication that these are non-mutating diagnostics, no mention of permissions, rate limits, or whether request_log entries could be large or sensitive. Only the indirect word 'health' hints at read-only intent.

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

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

One short, front-loaded sentence with zero filler. It is efficient, though its brevity is under-specification rather than genuine density; the words that remain are not redundant.

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 four-parameter, multi-mode dispatcher with no annotations and no output schema, the description should at minimum explain that the tool is a diagnostic read-only surface and which params bind to which actions. It does none of that, so an agent must reconstruct behavior from the enum text 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?

Schema coverage is 50%: 'action' and 'limit' are documented in the schema, but 'failuresOnly' and 'includeDetails' have no description anywhere, and the tool description does not compensate for them. It also never clarifies which parameters apply to which action (e.g., 'limit'/'failuresOnly' plausibly only for request_log), leaving a real ambiguity.

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 phrase 'Runtime health, status, capabilities, and request log actions' does signal the domain (runtime diagnostics rather than browser/task/file operations), which separates it loosely from siblings. But it is a noun phrase with no verb and 'actions' merely echoes the tool name suffix, so the actual operation is only inferred from the enum names in the schema.

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

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

There is no guidance on when to call this versus the 25 sibling action tools, no statement of prerequisites, and no exclusions. An agent must guess that 'ping' is a liveness check and 'status' is for connection state purely by reading the schema enum.

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

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

With no annotations, the description carries the full behavioral burden and delivers almost nothing. It does not disclose that `store` defaults to true (a persistence side effect), what crawling or snapshot-comparison do, whether actions require an active tab or authentication, or how results are returned. The distinction between the 'query_scrape' path and 'legacy' paths is asserted but never explained in terms of behavior or output.

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

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

It is a single front-loaded sentence with no filler, which is structurally sound. The trade-off is that brevity here comes at the cost of under-specification, and the terminal ellipsis ('extract_metadata, …') is a lazy stand-in that forces the agent into the schema rather than informing it.

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 14-parameter tool with a 15-value action enum, nested objects, no annotations, and no output schema, one sentence is far from enough to call it correctly. The description would need to at minimum map actions to their relevant parameters and disclose the storage side effect and return expectations; it does neither.

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 7% across 14 parameters, so the description must compensate and does not. It hints at URL inputs and a query object, but says nothing about tabId/tabIds, project, maxPages, sections, preset, source, store, or the before/afterSnapshotId pair, all of which are opaque from the schema alone. The bucketing of actions into 'GraphQL-style' vs 'legacy' also fails to clarify which parameters belong to which action.

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 verb+resource pair ('scrape and extract content') is stated, and the primary action (query_scrape) is named, which gives a rough sense of purpose. However, the description never distinguishes this tool from closely related siblings such as fileforge_browser_action, fileforge_search_action, or fileforge_page_interaction, and it trails off into an ellipsis instead of enumerating the 15 enum actions. An agent cannot confidently tell which scraping-adjacent 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?

There is a weak implicit preference signal in calling query_scrape 'GraphQL-style' and the rest 'legacy', which hints that query_scrape should be preferred. But there is no explicit when-to-use, when-not-to-use, prerequisite, or alternative-tool guidance, and no indication of when the legacy actions like crawl_site or research_site should be chosen over the modern one.

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 supplied, so the description carries the full behavioral burden, yet it says nothing about read-only semantics, ordering or relevance of results, default result caps, or pagination behavior. "Search" weakly implies a non-mutating operation, but nothing is confirmed and no operational constraints are disclosed.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, but its brevity is achieved by omitting information rather than by tight editing of rich 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 a required enum driving five distinct search modes, a `ref` scoping parameter, and no output schema or annotations, the definition is thinner than the tool's complexity warrants. The enum description in the schema rescues the action semantics, but the result shape, `ref` usage, and mode-selection guidance are absent.

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

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

Schema description coverage is only 25% — just the `action` enum is documented, and it is documented in the schema itself. The description does not explain `query` syntax, what `ref` refers to (presumably a page result identifier used with action=page), or how `limit` interacts with paging, so the three undocumented 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?

The description states a specific verb ("Search") and enumerates the resource types it covers (saved pages, results, notes, browser history, bookmarks), so the agent knows the tool's function without opening the schema. It does not differentiate against overlapping siblings such as fileforge_note_action or fileforge_result_action, 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?

There is no when-to-use guidance, no exclusion, and no named alternative, despite 25 sibling tools with obvious domain overlap (notes, results, browser, pages). The agent is left to infer that this is the multi-source entry point rather than a per-source one.

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 supplied, so the description carries the full disclosure burden and does not meet it. It never states that all actions are reads except export_query (which writes a file), where that file lands, whether queries are restricted to SELECT-only for safety, or that results are capped by limit/offset.

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

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

A single front-loaded sentence with no filler, which is the right shape for a dispatcher tool. It is arguably under-specified rather than wasteful, but nothing in the sentence is redundant.

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 multi-action tool with no annotations, no output schema, and low schema coverage, one sentence is far too thin. It should at minimum map parameters to actions and disclose the file-writing side effect of export_query.

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

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

Schema description coverage is only 38% across 8 parameters, and the description adds nothing about ref scoping, table, limit, offset, format, or filename. The agent must infer entirely from bare schema fields which parameters apply to which action.

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 enumerates four concrete verbs (list, describe, query, export) that map one-to-one onto the action enum, and scopes the resource as 'SQL-backed FileForge data', so an agent knows this is the SQL access surface. It does not differentiate from siblings like fileforge_export_action or fileforge_file_action, which overlap with the export/file-writing action.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as fileforge_export_action for export tasks. The verb list merely mirrors the action enum already documented in the schema, so no routing help is added.

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, but it only lists verbs. It implies that dry_run and validate are safer inspection modes, yet it does not disclose async execution behavior, destructive deletion, permissions, or side effects.

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

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

The description is a single compact sentence with no filler, so it is concise. However, the comma-separated verb list is poorly structured for an action-dispatch tool and omits the routing information an agent most 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?

For a mega-tool with 30 actions, 68 parameters, no annotations, and no output schema, one sentence is grossly inadequate. The description should surface action families and required parameter expectations rather than merely listing capabilities.

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?

With 68 parameters and only 19% schema description coverage, the description needs to compensate heavily, and it adds no parameter semantics at all. The action enum schema itself explains many actions, but the description does not help an agent map parameters to the relevant action.

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 lists many verbs but names the resource only broadly as FileForge routines and legacy task pipelines. It does not distinguish this tool from the many sibling FileForge tools or explain that the action parameter dispatches among 30 different operations.

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 when-to-use or when-not-to-use guidance, and no alternatives are named. An agent is left to infer from the action enum which operation applies, with no help from the description.

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 supplied, so the description carries the full behavioral burden, and it discloses almost nothing. It hints that artifacts are produced and stored ('export', 'artifacts') but never says that many actions write files to disk, that captures require a visible tab, that baselines persist between calls, or that comparisons depend on prior baseline state. The one genuinely useful behavioral note (TAB_NOT_VISIBLE) appears in the schema enum, not the description.

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 is efficient in the literal sense, with no filler or redundancy. But the brevity here is under-specification rather than concision, so it earns only a middling score: short and clean, yet far too thin for a 15-action 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?

This is a high-complexity multiplexed tool with 33 parameters, 15 actions, no annotations, and no output schema, and the description is one generic sentence. Nothing tells the agent which parameters apply to which action, what is returned, or what side effects occur. The definition is completely inadequate for the tool's complexity.

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

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

The schema exposes 33 parameters with only ~15% description coverage, so the description was expected to compensate and does not. It mentions no parameter names, no required 'action' dispatcher pattern, and no explanation of how fields like x/y, coordinateSpace, viewports, threshold, or run interact with particular actions. Zero added meaning 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 names specific verbs (capture, compare, inspect, export) and a resource domain (visual browser artifacts), so the general purpose is inferable. However, it never states that this is a multiplexed dispatcher over 15 distinct actions, and it does not differentiate the tool from plausible siblings such as fileforge_eye_action, fileforge_responsive_action, or fileforge_qa_testing. An agent reading only the description cannot tell what makes this tool distinct.

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 when-to-use guidance, no when-not-to-use guidance, and no named alternatives among the 25 siblings. The agent gets no signal about when to reach for visual capture versus the QA, responsive, or devtools tools that likely overlap. The only routing detail lives in the action enum inside the schema, not in the description.

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 supplied, so the description carries the full disclosure burden and delivers almost none of it: no statement of destructive effects (delete_recipe), stateful sequencing (start/stop recording), permission or browser-context requirements, or which parameters apply to which action. Only the word 'delete' hints at a destructive operation.

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

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

A single front-loaded sentence with no filler, but it is under-specified rather than concise. The verb list is essentially a restatement of the action enum instead of spending words on sequencing or parameter-to-action mapping.

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 nine parameters, nested objects, six distinct actions, no annotations, and no output schema, one generic sentence is far from sufficient. An agent cannot tell how to sequence start_recording/stop_recording, what export_recipe returns, or which action consumes inputs, capture, and assertions.

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

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

Schema description coverage is only 56% and the description adds no parameter meaning at all. It does not clarify which of the nine parameters matter for each action (e.g. that name/steps apply to recording, inputs/capture/assertions to run_recipe, format to export_recipe), leaving several parameters undocumented in both places.

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

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

The description names a specific resource (browser workflow recipes) and enumerates the five operations, which roughly maps to the six enum actions. However, it never explains what a 'recipe' is in this context or how this differs from sibling tools like fileforge_browser_action, fileforge_page_interaction, and fileforge_export_action, which plausibly overlap.

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 when-to-use guidance, no prerequisites (e.g. must be recording before stop_recording), and no routing to alternatives for overlapping capabilities like export or delete. The agent must infer everything from the action enum in the schema.

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