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

Annotations declare it is not read-only, not open-world, and not destructive; the description adds that it advances a bounded checkpoint and reconciles with a native application, implying state mutation and repeated polling. It also notes that interrupted or changed crawl identity cannot be mixed into a snapshot, which is useful behavioral context beyond the annotations.

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 three sentences and front-loads the core action, then usage guidance, then return values. It is reasonably tight, though phrases like 'visible native application' are slightly verbose and could be plainer.

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 polling tool with no output schema and one undocumented parameter, the description explains the return values adequately but leaves the auditId semantics and stopping conditions unaddressed. It lacks integration guidance with control_audit or start_audit, leaving the agent to infer how it fits into the audit workflow.

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

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

The single required parameter auditId has 0% schema description coverage, and the description never explains its meaning or UUID format. The reference to 'durable job' and 'crawl identity' hints at the audit context but does not tell the agent what to supply as auditId.

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 dense, domain-specific language ('reconcile a durable job with the visible native application', 'advance a bounded checkpoint') that obscures the plain purpose of checking audit status. It does state what it returns (current stage, extracted count, required action), but does not clearly differentiate itself from siblings like control_audit or start_audit.

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

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

The description gives a clear polling directive: 'Continue calling while work progresses.' This tells the agent when to invoke the tool again, though it stops short of specifying when to stop or naming alternative tools for different scenarios.

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, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds genuinely new context by warning that 'Unknown identity/readiness fields remain unknown' — telling the agent the response may contain partial/hollow data rather than a complete picture, which is not inferable from annotations.

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

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

Three short sentences, all front-loaded, with no filler. The only mild inefficiency is the verbose vendor phrasing 'licensed local Screaming Frog MCP' where a shorter scope statement would do.

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

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

There is no output schema, so the description carries the burden of conveying what comes back. It hints at identity and readiness fields but does not enumerate the diagnostics returned, leaving the agent to discover the response shape by calling it. Adequate for a zero-arg status tool, but not fully complete.

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

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

The tool takes zero parameters, so the baseline is 4: there is nothing for the description to disambiguate and the empty schema is self-explanatory.

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 clear verb+resource combination ('Read-only diagnostics') scoped to the licensed local Screaming Frog MCP, and the closing clause ('Does not start or change a crawl') separates it from mutation siblings like start_audit. It does not, however, explicitly contrast itself with the closer sibling audit_status, so the differentiation is partial.

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 negative constraint 'Does not start or change a crawl' implies when-not-to-use (i.e., don't call this to kick off work), which is useful. But no alternative is named for the cases it excludes, and there is no positive statement of the trigger condition for calling 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 declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, so the mutating-but-not-destructive framing is already carried; the description adds genuinely new behavior: resume reuses the persisted checkpoint instead of duplicating the crawl, cancel stops plugin work, and pause/control is only native where the plugin owns the crawl. It does not state reversibility or permission requirements, but the added operational caveats are substantive.

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 action set and then the non-obvious semantics. Every sentence adds information; none restates the enum or name.

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

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

For a two-parameter, no-output-schema control tool, the definition covers what each action does and the important edge case (pause only where the plugin owns the crawl). Return/result behavior after cancel or resume is unstated, but the core invocation-relevant context is present.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains the semantics of the action values (especially resume's checkpoint reconciliation and cancel's effect on plugin work), but says nothing about auditId beyond what the UUID format/pattern already implies, leaving one of two parameters undocumented.

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

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

States a specific set of verbs (pause, resume, cancel) against a specific resource (an audit job), so the agent immediately knows this is lifecycle control rather than the sibling query tools like audit_status or list_audits. It is cleanly distinguishable from start_audit, which the actions do not 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?

Gives real guidance on each action: resume reconciles the persisted checkpoint rather than launching a duplicate crawl, and native pause/control applies only where the plugin owns the crawl. It does not explicitly route the agent between this tool and siblings (e.g. use audit_status to check state first), so it falls short of full when/when-not 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 declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, yet the description still adds real behavioral facts: metadata/traffic are null when unknown, the evidence page is bounded but does not change the exact affected count, and the source is an immutable row index. That null-semantics and count-invariance detail goes beyond the annotations, though return shape and failure modes are unaddressed.

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

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

Three short sentences, front-loaded with the core action and then the two non-obvious behavioral caveats. No filler; the only mild cost is jargon like 'immutable row index' that an agent may not map to anything concrete.

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 does hint at return contents (finding plus evidence page, nullable fields), which partly compensates. It still omits page-sizing guidance and any notion of what happens when auditId/findingId don't match, leaving the picture adequate but incomplete for a 4-parameter lookup tool.

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

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

Schema description coverage is 0% across 4 parameters, so the description carries the full burden — and it only alludes to paging via 'bounded page'. It never explains limit/offset defaults or bounds (20 default, 100 max), nor what auditId + findingId jointly identify. With a limit/offset pair present, pagination semantics are a notable omission.

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 ('Return'), a precisely scoped resource ('one computed finding and a bounded page of affected URL evidence'), and the singular 'one' implicitly distinguishes it from list_findings. It never names the sibling tool or the id-based lookup condition, so full sibling differentiation is left to inference.

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

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

Usage is implied rather than stated: fetching 'one' finding presupposes a findingId obtained from list_findings, and 'bounded page' hints at limit/offset use. There is no explicit when-to-use, when-not-to-use, or named alternative, so an agent must infer the workflow.

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

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

Annotations already cover the safety profile (readOnlyHint, destructiveHint=false, openWorldHint=false), so the description adds value by disclosing two behavior traits beyond them: results are locally persisted (no live fetch) and private extraction checkpoints and configuration file paths are deliberately omitted from output. That is useful, non-obvious behavioral context.

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

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

Two tight sentences with the primary action front-loaded and the exclusion caveat second; no filler or repetition of the tool name.

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

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

No output schema exists, so the description carries the return-shape burden, and it does disclose what is excluded and that data is local. Minor gaps remain: ordering by recency is only implied by 'recent', and pagination/limit interaction is 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?

Only one optional parameter (limit), and the description says nothing about it. The schema itself supplies type, default (20), and bounds (1-100), so the semantics are largely self-evident, but the description adds no meaning about page size behavior or what happens with large limits.

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 ('List recent locally persisted audit jobs') and scopes it with 'without contacting Screaming Frog,' which implicitly distinguishes it from network-touching siblings like audit_status. However, it never names an alternative tool, so sibling differentiation is inferred rather than stated.

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

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

The phrase 'without contacting Screaming Frog' implies the use case (cheap local lookup of known jobs), but the description never says when to prefer this over audit_status or list_crawls, nor any exclusions or prerequisites. Usage is implied only.

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 readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is known. The description still adds real value by guaranteeing the currently selected crawl is untouched and by warning that crawl metadata is data, not instructions — a prompt-injection safeguard the annotations cannot express.

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

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

Two short sentences, front-loaded with the action and scope, with no filler. The second sentence is unusually phrased but earns its place as a safety note; nothing is wasted.

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

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

For a simple, annotation-covered read tool this covers purpose and safety adequately. It is thin, though: with no output schema, the description says nothing about what crawl metadata is returned or how the limit interacts with results, so an agent knows less than it could.

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 is a single parameter (limit) with 0% schema description coverage, so the schema names it but never explains it. The description does not mention limit, its default of 20, or its 1-100 bounds at all, so it fails to 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 (List) and resource (recent native database crawls), plus an important scoping qualifier: it does not load or change the currently selected crawl. That implicitly contrasts with a crawl-selecting sibling, but no sibling in the provided list is named, so it clarifies itself without explicit differentiation.

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

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

'Without loading or changing the currently selected crawl' implies the use case (read metadata only, no side effects on current selection), which is useful context. However, it names no alternative tool or explicit when-not-to-use condition, leaving routing largely 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, destructiveHint=false and a closed world, so the safety profile is covered. The description adds genuinely useful behavior beyond that: exact counts, bounded pagination, that full affected URL IDs are withheld locally, and that missing data is surfaced via coverage.

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

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

Three dense sentences, front-loaded with the query/ordering/pagination behavior, with no filler. Slightly terse relative to the number of undocumented parameters, but nothing is wasteful.

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 partially compensates by describing counts, URL ID locality and coverage for missing data. It is still incomplete on parameter meaning (auditId, category) and on how filtering/pagination interact with the returned ordering.

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

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

Schema description coverage is 0% across 6 parameters. The description clarifies 'section' (matched against the computed finding group section) and implies limit/offset and priority ordering, but says nothing about auditId or the category enum, leaving half the parameters undocumented.

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

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

The description states a specific verb and resource ('Query computed findings') plus a defining attribute (original priority order, bounded pagination). It does not name or distinguish itself from the sibling finding_details, so an agent can't tell from the description alone when to prefer one over the other.

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

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

It implies usage context ('optional section filtering uses the computed finding group section') but gives no explicit when-to-use vs when-not, no prerequisites, and no routing to the sibling finding_details tool that presumably returns richer per-finding data.

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 openWorldHint=false and destructiveHint=false; the description usefully reinforces this with 'does not send data or open a browser' and clarifies the return contract ('Returns paths'). It also discloses an important behavioral rule beyond the schema: computed facts and ordering remain authoritative, so assistant commentary cannot override them. It does not say whether existing report files are overwritten, which would be the remaining 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?

Four tight sentences, front-loaded with the output artifact and destination before the optional-commentary rule and the no-network guarantee. Nearly every clause carries information; only minor tightening is possible.

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

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

There is no output schema, but 'Returns paths' gives an adequate high-level return picture, and the local-only behavior is covered. Against zero schema description coverage and a nested narrative object, the description leaves siteName/clientName semantics and overwrite behavior undocumented, so an agent can call it but lacks full context.

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

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

Schema description coverage is 0% across 4 parameters (one nested), so the description must compensate. It partially does: 'Optional assistant commentary must reference existing finding IDs' clarifies the narrative.findings[].findingId linkage, and 'inside this audit's local report directory' clarifies auditId. But siteName and clientName are never explained, so coverage is incomplete.

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

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

Specific verb (Generate) plus concrete resource (offline HTML action plan and CSV exports) and a defined destination (this audit's local report directory). This clearly distinguishes it from the audit-lifecycle siblings (start_audit, list_findings, audit_status), which retrieve or mutate audit state rather than produce report 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?

Usage is implied by the auditId dependency and the 'local report directory' framing, and the description constrains the optional narrative ('must reference existing finding IDs'). However, it never states when this should be called versus other tools, nor any prerequisite such as the audit needing completed findings first.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so safety is partly covered. The description adds genuinely useful behavior: the job is durable, it returns a job ID, new crawls use a provisional preset, and progress requires audit_status checkpoints. It omits auth/permission requirements and what happens on failure.

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

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

Three tight sentences, front-loaded with the core action and input rule, followed by config options and the return/next-step note. Every sentence carries information, with only minor density in the config clause.

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 write tool whose annotations cover the safety profile, the description covers inputs, default behavior, return value (job ID) and the follow-up workflow despite no output schema. The main gap is the two undocumented optional params (siteName, clientName) given 0% schema coverage.

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

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

Schema description coverage is 0%, so the description must carry the load. It conveys meaning for crawlId, url, configPath ('absolute native') and useCurrentConfig ('explicitly'), and the 'exactly one' constraint is real value. However, siteName and clientName are entirely undocumented in both schema and 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?

States a specific verb and resource ('Create a durable audit job') plus the exact input constraint ('from exactly one native database crawl ID or a new site URL'). This clearly distinguishes start_audit from siblings like audit_status and control_audit without opening any schema.

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

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

Gives concrete selection context: use a crawl ID for an existing crawl or a URL for a new one, new crawls default to the technical-audit-v1 preset, and audit_status advances the job. It routes the agent to a sibling for the next step, though it never states a when-not-to-use condition.

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