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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that results are severity-rated and lists the anomaly classes detected, which is useful context, but it says nothing about how severity is assigned, whether alerts are ranked or capped, or what the response looks like.

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 dense sentence with the most important framing (severity-rated alerts) front-loaded and no filler. It is a noun phrase rather than a complete statement, which slightly weakens readability but wastes nothing.

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 9-parameter tool with no output schema and low schema coverage, the description covers the detection surface but not the return shape, severity semantics, or the role of the comparison window and search type. It is adequate to decide to call it, but not to predict or interpret results.

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 22%, so the description must compensate. It partially does: the enumerated alert types map onto ctr_drop_pct, position_drop, click_drop_pct, and site_drop_pct, giving implicit meaning to those thresholds. However, days, search_type, min_clicks, and min_impressions remain unexplained in both places, leaving a real gap.

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

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

The description names a specific resource (severity-rated alerts) and enumerates the exact detection categories: site-wide click drop, query position drops including falling off page one, CTR collapses at the same position, page click losses, and vanished pages. This is far more specific than a tautology and lets an agent distinguish it from generic siblings like traffic_drops or content_decay, though it never states the verb or that it is a bundled diagnostic scan.

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 exclusions, and no reference to alternatives. With siblings such as traffic_drops, content_decay, and find_opportunities in the same family, an agent gets no signal about when this bundled alert check is preferable to those narrower tools.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety and external-network behavior are covered structurally. The description usefully adds that verification tokens are also fetched from the home page (an HTTP fetch beyond pure DNS), but it omits what happens for an unregistered/invalid domain, whether failures are returned as errors or empty results, and how long the lookup takes.

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 tightly-packed sentence with no filler, and the highest-value information (which record types) comes first. It loses a point for being a sentence fragment with no verb, which slightly weakens front-loading of the actual action.

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 small two-parameter read-only tool with no output schema, enumerating the returned record types is genuinely the right content since nothing else describes the return shape. However, the undefined include_www parameter and the total absence of usage context leave real gaps for an agent deciding when and how to call it.

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 only 50% schema description coverage, the description must compensate and does not: it never explains that domain accepts an sc-domain property form, and include_www (default true) is completely unaddressed even though it likely controls the home-page fetch hinted at. The only implicit connection is 'on the home page', which does not explain the parameter's effect.

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 the exact data returned (A, AAAA, CNAME, MX, NS, TXT, CAA records plus Google verification tokens) but is a bare noun phrase with no verb, so it never explicitly says it looks these up for a domain. It is distinguishable from siblings like robots_txt_check and check_https, but only by the record-type list rather than by a stated 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 at all: nothing says to call this when diagnosing DNS/verification problems, and nothing distinguishes it from check_https, check_redirects, or robots_txt_check, which an agent could plausibly pick for a related diagnostic task. The reader must infer the use case 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile and the fact that this reaches live network state are covered. The description adds the useful detail that the checks are HTTPS-specific (cert chain, redirect, HSTS, mixed content), but says nothing about latency, whether checks are live vs cached, or failure modes for unreachable hosts.

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 dense sentence with the resource and the checked facets front-loaded, and the parenthetical justification for the tool's existence is short and earns its place. The telegraphic fragment style reads slightly clipped, but there is no wasted 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?

For a read-only, two-parameter network check with no output schema, the description covers the substantive surface: it enumerates what is inspected, which effectively previews the result categories. The remaining gap, how results are shaped or whether a partial failure yields partial output, is minor.

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

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

Schema description coverage is 100%, so both parameters (host_or_url and the optional urls array with its max-100 constraint) are already documented in the schema. The description adds no further meaning about the relationship between host_or_url and urls, so the baseline 3 applies.

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

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

The description names a specific verb+resource ('HTTPS health') and enumerates the exact facets checked: certificate validity/expiry/names, http->https redirect, HSTS, mixed content. That is far more specific than the bare name 'check_https'. It does not explicitly distinguish itself from the nearby check_redirects or check_dns siblings, which keeps it short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative is named. The parenthetical ('Search Console's HTTPS report has no API') explains why the tool exists but does not tell the agent when to reach for it instead of check_redirects or server_status.

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 readOnlyHint=true and openWorldHint=true already declaring safety and network access, the description adds real behavioral context: it reports every hop, final status, loops, temporary redirects, and https->http downgrades. That tells the agent what observations will come back and what pathological cases are detected. It does not describe rate limits, error handling, or result format, which keeps it below a 5.

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

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

The definition is a single, front-loaded sentence that packs the core purpose and expected findings without filler. The semicolon-separated list is dense but readable. Minor redundancy exists between "redirect chains" and the later "chains" item.

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 must carry return-value meaning, and it does by enumerating hop tracing, final status, loops, temporary redirects, and https->http findings. It also covers both operating modes (urls and pairs). It stops short of explaining result structure or concurrency behavior, but for a read-only bulk checker it is largely complete.

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

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

Schema coverage is 67%, so the baseline is 3. The description adds meaning for urls ("in bulk") and pairs ("validates migration redirect maps"), clarifying that pairs verifies each old URL ends at its new URL. However, concurrency is completely undocumented in both schema and description, leaving a clear gap.

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

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

The description states a specific verb and resource: "Trace redirect chains in bulk." It then enumerates the exact findings (every hop, final status, loops, temporary redirects, https->http) and the migration-map validation mode. This makes the tool clearly about bulk redirect tracing rather than HTTPS or DNS checking, though it does not explicitly name sibling tools.

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

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

"In bulk" implies this is the tool for many URLs rather than single-URL inspection, and "validates migration redirect maps" signals the pairs mode. However, there is no explicit when-not guidance, no named alternatives such as check_https or inspect_url, and no statement of prerequisites or limits beyond what the schema already provides.

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 and openWorldHint=true, so safety is covered; the description adds the implicit default comparison window and the presence of new/lost entities in the result. It omits consequential behavior: that min_impressions (default 10) silently suppresses low-volume entities, how results are ranked/truncated by top_n, and that missing previous_start/previous_end triggers auto-derivation.

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 tight sentence with no filler, and the core behavior plus its default are front-loaded. It is arguably over-compressed for an 11-parameter tool, but nothing in it 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 an 11-parameter comparison tool with no output schema, the description should say what is measured (clicks, impressions, CTR, position deltas), how rows are ordered and cut off, and how min_impressions affects candidate entities. None of that is present, leaving the agent unable to predict or interpret the response.

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 82%, so the baseline is 3 regardless of the description. The only parameter-level meaning added is the automatic previous-period derivation implied by the parenthetical; top_n and min_impressions remain undocumented in both places, and the description does not explain how dimension interacts with the "new and lost" framing.

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?

"Winners and losers between two periods" conveys a delta/comparison operation, and "with new and lost queries/pages" hints at the output content. But it never says which metrics are compared, and it does not distinguish itself from siblings that also measure change over time (traffic_drops, content_decay, performance_overview), so an agent must guess which tool to reach for.

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

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

The parenthetical "(default: previous equal-length period)" tells the agent what happens when no comparison window is supplied, which is real usage guidance. However there is no when-to-use/when-not-to-use statement and no pointer to the obvious alternatives (performance_query for a single period, traffic_drops for decline diagnosis).

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 and openWorldHint=true, so the safety profile is covered. The description adds the meaningful behavioral rule that the decline must occur in every consecutive period, but says nothing about result ordering, which period is the baseline, or what happens when the threshold is not met.

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 sentence, front-loaded with the resource and the qualifying condition, with no wasted wording. It is compressed to the point of being slightly cryptic, but every clause earns its place.

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

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

There is no output schema, so the description could explain what a result entry looks like, but it does define the core selection logic well enough to call the tool correctly. With eight parameters and low schema coverage, several knobs remain undocumented in both places.

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%, so the description needs to compensate, and it only partially does: 'N consecutive periods' maps to periods and 'clicks fell' loosely to min_decline_pct, and 'pages or queries' maps to dimension. It adds no meaning for top_n, min_clicks, period_days, search_type, or the accepted site formats.

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 (pages, or queries) and the specific selection criterion (clicks fell in every one of N consecutive periods), and it distinguishes the concept from a one-off dip. An agent can tell this apart from generic drop-detection siblings such as traffic_drops, though it never names the sibling explicitly.

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

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

The 'slow decay, not a one-off dip' framing implies when this tool is the right choice, but no alternative tool is named and no conditions or prerequisites are stated. Usage is inferable rather than directed.

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 and openWorldHint=true, so safety and external-network behavior are covered. The description adds one genuinely useful non-annotation fact — the CRUX_API_KEY credential requirement — but says nothing about low-traffic origins returning no data, rate limits, or latency, which are the real failure modes for a CrUX query.

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 dense sentences with zero filler: the resource and metric list come first, then the source and credential prerequisite. Nothing is repeated and nothing needs to be trimmed.

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 usefully enumerates the returned metrics and their p75 aggregation, which is the minimum an agent needs. It stops short of describing the response shape (e.g. per-form-factor breakdown or URL-vs-origin granularity) and the empty-data case, but it is complete enough to call the tool correctly.

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

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

Schema coverage is 100%, so 'target', 'history', and 'form_factor' are already fully documented, and the description's mention of the 'latest 28-day window' merely restates the history parameter's schema text. Its one addition is the 'p75' percentile framing, which clarifies that metrics are reported as percentiles rather than averages — useful but minor.

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 (Core Web Vitals / CrUX field data), the exact metrics returned (LCP, INP, CLS, FCP, TTFB at p75), and the upstream source (Chrome UX Report). The word 'field data' implicitly separates it from a lab-data sibling like performance_overview or a rendered-page audit, but no sibling is named, so differentiation is inferred rather than stated.

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

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

It gives implied context — real-user field data behind Search Console's CWV report — which suggests when an agent should reach for it. However, it never says when to use an alternative (e.g. lab-based speed tooling for page-level diagnostics) or when this tool is inappropriate, so the agent must infer routing from the phrase 'field 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful return-content context (daily series, breakdowns, robots.txt fetches, example URLs) which matters since there is no output schema, but it omits prerequisite state (logs must be imported), default date-range behavior, and result-size 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?

A single front-loaded sentence that leads with the core action and then enumerates outputs; no filler or redundant phrasing. The semicolon-delimited list is dense but readable, though it reads slightly like a feature dump rather than prioritized guidance.

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, zero-required analytics tool with no output schema, the description does the important work of enumerating what comes back. It still leaves out the dependency on prior log import and any guidance on date-range defaults or data volume, which an agent needs to call it sensibly.

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

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

Schema coverage is 100%, so every parameter is already documented, making 3 the baseline. The description loosely maps its breakdown list to parameters such as response, bot_types, and host, but adds no format or interaction detail (e.g., how response interacts with top_urls) beyond what the schema already provides.

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

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

States a specific resource and source: crawl statistics derived from imported access logs, with an enumerated list of metrics (requests, download size, response time) and breakdowns (response, file type, Googlebot type, purpose, host). An agent can distinguish it from siblings like performance_query or import_access_logs by the 'from your logs' framing, though no sibling is named explicitly.

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

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

Usage is only implied: 'from your logs' hints that access logs must already be imported, but the description never states that prerequisite or says when to prefer this over performance_query or import_access_logs. There are no exclusions or alternative-selection rules.

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, openWorldHint=true, destructiveHint=false, so the agent knows this is an outward-facing operation with some side effect. The description adds real context by noting it combines Google's inspection API with a live fetch, which explains the non-read-only hint, but it does not say whether quota is consumed, whether results are cached, or what the interaction with use_cached_inspection means. Useful but incomplete 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?

Two sentences, zero filler: the diagnostic question is front-loaded and the enumerated checks follow immediately. Every clause carries information an agent can use to decide whether to call 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 four-parameter diagnostic tool with no output schema, the description does the important work of telling the agent what signals come back (redirects, status, noindex, canonicals, robots rule, thin content), so the return value is not a mystery. What is missing is the cost/rate-limit dimension of running a fresh inspection versus a cached one.

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

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

Schema description coverage is 100% and the schema itself explains site formats, user_agent options, and the cached-inspection flag well. The description's reference to "a live fetch" and "Google's inspection" loosely maps to user_agent and use_cached_inspection but adds no format or defaulting detail beyond the schema. Baseline 3 applies.

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

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

Opens with a specific diagnostic question ("Why is this URL (not) indexed?") and enumerates the concrete checks it performs: redirect chain, status, noindex, canonicals, robots.txt rule, thin content. That verb-plus-resource framing clearly separates it from single-purpose siblings like robots_txt_check or check_redirects, since this one aggregates them. It stops short of naming a sibling explicitly, which is why it is a 4 rather than 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?

The "Why is this URL (not) indexed?" framing implies the use case: per-URL indexing diagnosis. But nothing states when to prefer this over inspect_url, check_redirects, or robots_txt_check, all of which appear in the sibling list and overlap with pieces of this tool. Usage is inferable rather than guided.

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 and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral trait — that www/non-www, http/https, slash and parameter variants are reported as separate findings rather than as competing pages — but says nothing about thresholds applied, result ordering, or what a finding contains.

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 core purpose front-loaded and the output-disambiguation detail second. No filler, no restatement of the tool name, and nothing an agent must read past to get the 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?

With 8 parameters, no output schema, and only two annotations, the description leaves material gaps: it does not say what a returned finding looks like (query, URL list, impression shares), how results are ranked or capped by top_n, or when the data window ends. It is adequate to select the tool but thin for interpreting results.

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 75%, so most parameter meaning (site format, date windows, min_share, start_date precedence over days) is already documented in the schema. The description contributes no additional parameter semantics, and undocumented fields such as top_n and min_impressions receive no help here. Baseline 3 is appropriate given the schema already carries the load.

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

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

Names a specific analytical operation on a specific resource: queries where 2+ URLs split impressions. The second sentence usefully disambiguates URL-variant duplication from real page competition, which is the key semantic distinction for this tool. It does not name a sibling (e.g. find_opportunities) to contrast against, so it stops short of a 5.

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

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

Usage is only implied: an agent can infer this is a cannibalization audit for a given property, but there is no explicit 'use this when X, not Y' guidance and no mention of prerequisites such as Search Console property access or data availability windows. The clarification about variants being reported separately hints at interpretation but not invocation.

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 and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful behavioral context by explaining that CTR is benchmarked against this site's own CTR-by-position curve rather than a global average, but it says nothing about the position band defaults that define 'striking distance' or how min_impressions/top_n shape results.

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 sentence with the actionable framing ('Quick wins') front-loaded and three parallel clauses that each carry information. No padding, though the parenthetical CTR clause is slightly dense relative to the rest.

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 nine parameters and no output schema, the description does useful work by defining the three result categories an agent will receive. It remains incomplete on how the position band, impression threshold, and top_n constrain each of those categories, and it never states that results are limited/scored.

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 56%, and notably position_from, position_to, and top_n carry no schema descriptions at all. The description partially compensates by tying 'ranking below 20' to the position ceiling and 'top positions' to the lower bound, giving the position band meaning, but it leaves min_impressions, top_n, and the interaction between days/start_date/end_date unexplained.

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 precisely by enumerating three concrete finding types (striking-distance query/page pairs, low-CTR top positions, content gaps ranking below 20), which tells an agent exactly what this tool returns. It is distinguishable from siblings like performance_query or content_decay by its 'opportunity' framing, though the verb itself is left to the tool name rather than stated in the description.

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?

'Quick wins' implies a use case (finding actionable improvement candidates) but the description never says when to pick this over performance_query, content_decay, or query_segments, nor any prerequisites such as needing Search Console data for the site. No exclusions or alternative routing are given.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the mild qualifying context that the sitemap must be a 'submitted' one; it says nothing about permission requirements on the property, rate limits, or error behavior for an unknown sitemap_url. With annotations carrying the safety burden, this is adequate but thin.

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

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

A single short sentence with no wasted words, and the scope qualifier ('one submitted') is front-loaded. Its brevity shades into under-specification rather than verbosity, but as a structural matter it is clean and easy to parse.

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 simple two-parameter read tool with fully documented parameters and safety annotations, so little is required. However, with no output schema, the description never indicates what 'details' are returned (last download, errors, warnings, submitted URL count), leaving the agent to guess at the response shape.

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%, with both 'site' (three accepted formats) and 'sitemap_url' (full URL) documented in the schema itself. The description adds no format, matching, or validation detail beyond that, so the baseline of 3 applies.

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

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

The description names the resource (a sitemap) and its scope ('one submitted'), which implicitly distinguishes it from the sibling list_sitemaps that returns many. The verb is weak ('Details of') rather than an explicit 'Get', and no sibling is named, so it is clear but not maximally differentiated.

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

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

Usage is only implied: the singular 'one submitted sitemap' plus the required sitemap_url suggests calling this when you already know which sitemap you want, versus listing them first. There is no explicit when/when-not guidance, no mention of list_sitemaps as the alternative, and no note that the sitemap must already have been submitted to the property.

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 and openWorldHint=true, so the safety profile is covered. The description adds little beyond the schema: it does not disclose that pages are fetched live, how long a 10-page audit takes, or what happens when check_files triggers up to 30 header requests per page. The 30-per-page fetch detail lives in the schema, 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 dense sentence that front-loads the purpose and then lists checks in a compact comma-separated form. No filler or repetition, though the run-on enumeration makes it slightly harder to scan than a short lead sentence plus bullets.

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 should clarify what an agent gets back (per-page findings? issue counts? severity?) and should cover the two undocumented tuning parameters. It defines the audit scope well but leaves output shape and threshold semantics unaddressed for a tool that takes four parameters.

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 'urls' and 'check_files' carry schema descriptions (50% coverage), leaving large_kb and max_images undocumented in both places. The description mentions 'file size' and 'broken images' but never explains that large_kb is a size threshold (default 300 KB) or that max_images caps images analyzed per page, 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?

The description names a specific verb and resource ('Image SEO audit of pages') and enumerates the concrete checks performed: alt text, file names, width/height, lazy loading, formats, file size, broken images, og:image, structured data. This is clearly distinguishable from siblings like pagespeed_audit or inspect_url. It stops short of explicitly naming the nearest sibling, so it does not reach 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?

Usage is only implied by the enumerated checks – an agent can infer it is for image-level SEO review of a set of pages. There is no statement of when to prefer this over pagespeed_audit or inspect_url, and no mention of prerequisites or cost implications of auditing multiple URLs.

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, openWorldHint=true and destructiveHint=false, and the description adds genuinely non-obvious behavior: the job runs in the background and already-imported files are skipped (idempotent-ish re-runs). It does not say how the caller learns when the import finished, but the background/idempotency disclosures are real value beyond 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?

Two short sentences, zero padding, with the core purpose front-loaded and the operational caveat (background, skip already-imported) immediately after. Nothing to trim.

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 should say what the caller gets back from an import (job id, status handle, or counts) — 'runs in the background' hints at async but leaves the retrieval path unstated. All parameters being optional is also left implicit, relying entirely on the 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?

All four parameters are fully documented in the schema (100% coverage), including the enum for response_time_unit and the 'omit paths to see import progress' usage. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Import) plus concrete resources (Apache/Nginx/Varnish access logs) and the outcome (rebuild Crawl stats). It is distinguishable from siblings like crawl_stats, though it never names that sibling or explains the relationship explicitly.

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

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

Usage is only implied by the stated purpose: you run this when you want Crawl stats rebuilt from server log files. There is no explicit when-to-use/when-not guidance, no mention of alternatives (e.g. crawl_stats, run_inspections), and no prerequisites such as needing access to local log paths.

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 and openWorldHint=true, so the safety profile is covered. The description adds the meaningful behavioral detail that results depend on two prior inspections and that a trend series is returned alongside the change list, but it omits what happens for URLs with fewer than two inspections and how 'days' bounds the trend window.

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

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

One compact sentence that front-loads the primary result and appends the secondary trend output. The parenthetical examples earn their place; the trailing '...' is slightly sloppy but the sentence is otherwise tight.

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 three-parameter tool with a third of its schema undocumented and no output schema, the description should explain 'days' and 'limit' and the precondition of existing inspection history. It covers the return concept but leaves an agent unable to reason about the window size or result count before calling.

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

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

Schema description coverage is only 33% — only 'site' is documented, while 'days' and 'limit' have no schema descriptions. The description's mention of a 'per-day inspection trend' hints that 'days' controls the window, but it says nothing about the row cap implied by 'limit', 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?

The description names the specific resource (URLs whose coverage reason changed between the last two inspections) and the secondary output (per-day inspection trend), with concrete examples like 'dropped out of the index, newly indexed'. It is distinguishable from siblings such as list_inspected_urls or indexing_report, though it never states the verb explicitly.

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

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

There is no explicit when-to-use guidance and no mention of alternatives among the many indexing/inspection siblings (indexing_report, list_inspected_urls, inspect_url). The only implied precondition is that URLs must have been inspected at least twice, which the agent has to infer from 'between their last two inspections'.

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 and openWorldHint=true, so safety is covered. The description adds real value beyond that by disclosing the shape of the returned content (meaning, issue attribution, what to check, how to fix), which is the main behavioral question for a no-output-schema tool. It does not clarify whether the content is static documentation or derived from live property data, which is the one remaining 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?

One tightly constructed sentence that front-loads the core resource ('what each Page indexing reason means') and then enumerates the three additional things it returns. No filler, no repetition of the name or schema.

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

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

For a one-optional-parameter reference tool with no output schema, the description is nearly sufficient: it tells the agent what categories of information come back and implies a static knowledge lookup. A short note on whether the guide is generic or property-specific would close the last gap.

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

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

Schema coverage is 100% and the schema itself explains the single optional 'reason' parameter, including 'omit for all'. The description adds no further meaning about accepted reason values or format, so the schema does all the work and the baseline of 3 applies.

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

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

The description clearly frames a reference/lookup tool: it returns the meaning of a Page indexing coverage reason, classifies it as a site vs. Google-systems issue, and supplies check/fix steps. That is a distinct purpose from siblings like indexing_report or diagnose_url, though it never names those siblings to make the contrast explicit.

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

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

Usage is only implied: an agent can infer you call this once you have a coverage reason and need to interpret or remediate it. There is no explicit when-to-use statement, no statement of when not to use it, and no pointer to indexing_report / diagnose_url / inspect_url as the tools for obtaining the reason in the first place.

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 and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavioral fact beyond that: the report is computed from previously stored local inspections rather than triggering fresh crawls or API calls. It says nothing about result size, pagination, or behavior when no inspection data exists yet.

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 identifying the report, followed by a compact semicolon-delimited list of contents — no filler. The dense enumeration is a bit listy, but every fragment maps to actual report content, so 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?

With six parameters, high schema coverage, and no output schema, the description must convey what comes back — and it does reasonably well by enumerating report sections. It omits the key operational precondition (inspections must already have been run) and any sense of report scope or limits, which matters for a report-generation 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 83%, so the schema already documents site format, source enum, and the sitemap/url filters; baseline 3 applies. The description adds little beyond that, and its use of 'source' ('every reason with source') refers to reason provenance rather than the 'source' queue parameter, which is mildly confusing rather than helpful.

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

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

States a specific resource (page-indexing report) and enumerates what it covers: indexed vs not, reasons with source, samples, canonicals, fetch/robots state, crawl age, rich results. The phrase 'from local inspections' distinguishes it from live-lookup siblings like inspect_url or diagnose_url, though it never names those siblings explicitly.

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

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

There is no explicit when-to-use guidance and no named alternative. The only implicit cue is 'from local inspections', which hints that inspection data must already exist (via run_inspections / queue_urls), but this prerequisite is never spelled out, nor is it clear when an agent should pick this over indexing_changes or list_inspected_urls.

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 readOnly=false, destructive=false, openWorld=true, so the safety profile is covered. The description adds genuine behavioral context beyond that – it runs in the background, respects a daily quota, and resumes after restarts – but stays silent on the state-changing action parameter and what a start call actually enqueues.

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 tight sentence with the key runtime constraint front-loaded after the core purpose. Nothing is wasted, though the space saved is not spent on the operationally important action semantics.

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 job-control tool with three action modes and no output schema, the description should at minimum explain what start, stop, and status return. It covers the long-running/quota behavior well but leaves the control surface, which is the primary invocation path, unexplained.

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 every parameter including the action enum is documented in the schema itself. The description hints at the daily quota concept (mapping loosely to daily_limit) but adds no syntax or semantics beyond what the schema already states.

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 indicates a background inspection job that drains a queue, but never states the controlling verb set (start/stop/status) that the tool actually exposes. It also does not differentiate it from sibling tools like run_inspections or queue_urls, so the agent must infer the distinction from the name.

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

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

It gives a runtime precondition (Claude Desktop must be open), which is useful context, but there is no guidance on when to use this versus run_inspections, and no indication of when each action value (start vs stop vs status) is appropriate.

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

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

Annotations declare readOnlyHint=false and openWorldHint=true, but the description's phrase 'Stored locally' implies a cached read, creating tension about whether the call mutates or merely retrieves state. It also omits quota/cost behavior, which is significant for a live Google URL Inspection call, and says nothing about what happens when no stored result exists.

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 compact sentence with no filler, and the core subject (URL Inspection result from Google) is front-loaded. The parenthetical field list is dense but earns its place by conveying the scope of returned data.

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 only three well-documented parameters and no output schema, the definition is minimally sufficient, but it leaves key questions open: whether the result is live or cached, what is returned when nothing is stored, and how it relates to the queue/run_inspections workflow. Annotations cover the safety profile only partially, so the description should carry more behavioral weight than it does.

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 all three parameters (url, site, language) are already documented in the schema, including the accepted property formats. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

The description identifies the resource (Google URL Inspection result) and enumerates fields it covers, but never uses a clear action verb — it reads like a resource label rather than stating whether the tool fetches a stored inspection, triggers a live one, or both. It also does not distinguish itself from siblings like diagnose_url, run_inspections, or list_inspected_urls, leaving the agent to guess its precise role.

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 mention of prerequisites (does the URL need to be queued or previously inspected?), no exclusions, and no routing to alternatives such as queue_urls/run_inspections for new inspections or list_inspected_urls for enumeration. The agent must infer all of this from sibling names 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the relevant operational traits: filtering, sorting, paging and CSV export. It does not say what export_csv actually returns (raw CSV text vs. a file path), how paging interacts with offset/limit, or any limits on heavy queries, so it adds moderate but not rich 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?

A single front-loaded sentence that names the resource and the capability set with no filler. Its terseness is efficient, though it borders on under-specification for a 15-parameter 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?

There is no output schema, 15 parameters at 47% coverage, and the description does not explain the returned record shape (URL, coverage state, rich results, optional performance metrics), the effect of with_performance_days, or CSV export mechanics. For a tool of this complexity the description is materially incomplete.

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

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

With 15 parameters and only 47% schema description coverage, the description carries a heavy burden, yet it only gestures at 'filtering, sorting, paging and CSV export.' Undocumented parameters such as url_regex, url_contains, descending, has_rich_issues, and the semantics of export_csv vs. limit/offset receive no explanation, so the agent must guess behavior from bare titles.

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

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

States a specific verb+resource: a URL-level listing of stored inspection data, with filter/sort/page/export capabilities. That is enough to separate it from inspect_url or diagnose_url, which perform new inspections rather than list stored results, though the description never names those siblings explicitly.

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

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

The phrase 'stored inspections' implies this reads previously collected data rather than running new audits, and the filter/sort/export list implies analytic drill-down. However, there is no explicit when-to-use or when-not-to-use guidance against siblings like indexing_report, crawl_stats, or inspect_url, leaving the agent to infer selection.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds that results are scoped to the account and include permission level, but it does not describe pagination, ordering, or return shape beyond that.

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 redundant wording. It communicates the resource and returned permission level efficiently.

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

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

For a zero-parameter discovery tool with read-only annotations and no output schema, the description covers what is listed and the key returned field. It could mention how many or in what format properties are returned, but it is adequate.

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

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

The tool has zero parameters, so there are no parameter meanings to add beyond the schema. The baseline for a no-parameter tool is 4.

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 (list) and resource (Search Console properties) and scopes it to those the Google account can access. It is clear, though it does not explicitly differentiate itself from property-specific siblings such as property_overview.

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 guidance, no named alternative, and no prerequisite indicating this should be called to discover property names before using property-specific tools. Usage is only inferable from the name and 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful content about what the response contains (last submitted/downloaded timestamps, pending state, errors, warnings, URL counts by type), which is real value beyond annotations, but it says nothing about pagination, entry limits, or behavior when the property has no sitemaps.

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 compact sentence that front-loads the resource and then enumerates the returned fields; nothing is wasted. It is slightly under-specified rather than verbose, but structurally clean.

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

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

For a simple two-parameter read tool with an output schema absent, the description adequately compensates by enumerating the returned fields. It falls short on the relationship to sibling tools and on any volume or pagination expectations, which an agent would need for correct invocation strategy.

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%, with both the site format and the sitemap_index filter documented in the schema itself. The description adds no additional meaning about the sitemap_index filtering behavior, so the baseline 3 applies.

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

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

The fragment 'Sitemaps submitted for the property' identifies the resource and scope, and the trailing list names the data fields returned, so the agent can infer this is a read/list operation. However, there is no explicit verb and no differentiation from sibling tools such as get_sitemap or queue_from_sitemaps, leaving the agent to guess at the distinction.

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

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

The description contains no when-to-use guidance, no prerequisites, and no mention of alternatives. An agent facing a large sibling set including get_sitemap and queue_from_sitemaps gets no help deciding which to call.

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 and openWorldHint=true, so safety is covered. The description adds genuine behavioral context — results are compared against a previous period and properties are flagged as dropping/growing — but says nothing about how many properties are returned at once, ordering, or what a 'flag' looks like in the response.

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 dense sentence with the multi-property scope front-loaded and no wasted words. The telegraphic style ('flagged dropping/growing') is terse to the point of being slightly clipped, but nothing 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?

With no output schema, the description does double duty and only partially delivers: it lists the metrics and the dropping/growing flag concept, which is the minimum needed to interpret results, but omits any indication of response shape or per-property structure. Adequate for a 3-parameter read-only aggregation tool, but thin.

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 67%; drop_pct and properties are already documented in the schema. The description's 'vs previous period' implies the days window governs both the current and comparison ranges, which adds real meaning the bare 'Days' schema field lacks, but it never states this explicitly nor explains the 7–90 bounds.

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+resource ('health check across many properties') and enumerates the metrics returned (clicks, impressions, CTR, position) plus the comparison and flagging behavior. 'Across many properties at once' implicitly separates it from single-property siblings like property_overview, though no sibling is named explicitly.

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

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

The phrase 'health check across many properties at once' implies the usage context (multi-property triage), but there is no explicit when-to-use vs. when-not, and no pointer to alternatives such as property_overview, compare_periods, or traffic_drops for drilling into a single site or a specific anomaly.

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 and openWorldHint=true, so safety and external-call behavior are covered. The description adds a genuinely useful prerequisite — it consumes PAGESPEED_API_KEY or CRUX_API_KEY when set — but says nothing about what happens without keys, rate limits, or how long the audit takes, which matters for a live external API call.

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 dense sentence with no filler, front-loading the data returned and ending with the credential note. It is efficient, though the comma-list of outputs reads as a feature dump rather than a structured lead-in.

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 usefully enumerates the return payload, and it covers the API key prerequisite. However, for a 3-parameter external audit tool it omits parameter guidance and any hint about usage relative to the many sibling performance tools.

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 33%: only 'categories' is documented in the schema, while 'url' and 'strategy' carry no description. The description adds no parameter meaning at all — it never mentions strategy defaults, that url must be a publicly reachable page, or what happens when categories is null, 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?

The description enumerates what the tool returns (Lighthouse scores, lab metrics, opportunities by savings, failing SEO audits, field data), which makes the underlying action — run a PageSpeed Insights audit — easy to infer. It never states the verb explicitly and does not distinguish itself from siblings such as core_web_vitals or performance_overview, which also cover performance/field data.

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 exclusions, and no named alternative. An agent choosing between pagespeed_audit, core_web_vitals, performance_query, and diagnose_url gets no routing help beyond the output 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that results are compared against a previous equal-length period, which is useful behavioral context about the output, but says nothing about rate limits, quota cost, or data-freshness/lag that matter for a Search Console analytics call.

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

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

Two short sentences with the substantive content first and no filler. The phrasing is telegraphic and lacks a verb, but 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 read-only reporting tool with a fully documented 5-parameter schema and no output schema, the description tells the agent what it receives (totals, comparison, daily series, top queries/pages). What is missing is routing guidance against the many overlapping performance siblings, which is the main decision an agent faces here.

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 all five parameters, including date formats and the days/start_date interaction, are already documented in the schema. The description's search_type note adds no meaning beyond the enum description already present, so the baseline of 3 applies.

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

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

The description names the concrete outputs — totals vs the previous equal-length period, daily series, top queries and pages — so an agent knows exactly what resource shape it gets back. It does not distinguish itself from near-siblings like compare_periods, performance_query, or property_overview, 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?

The only usage direction is 'Use search_type=discover for Discover', which is a restatement of the enum documentation rather than a when-to-use rule. There is no guidance about when this overview is preferable to compare_periods or performance_query, despite those siblings existing.

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 and openWorldHint=true, so safety is covered. The description adds useful output context by naming the performance metrics available and the flexible grouping/filtering scope, but it does not disclose row-limit behavior, pagination, CSV export side effects, data freshness, or aggregation semantics beyond what the schema already states.

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, and the metric list is efficient. It is slightly too terse for a 13-parameter tool, but the wording itself is clean and structurally sound.

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 complex 13-parameter tool with no output schema, the description is only minimally adequate. It identifies the metrics and query flexibility, but it omits return shape, pagination/row-limit behavior, CSV export implications, and how aggregation or data_state affect results, leaving much of the operational context to the 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 100%, so the schema already documents all 13 parameters, including dimensions, filters, dates, row limits, CSV export, and aggregation. The description adds no parameter-level meaning beyond echoing dimensions, search type, date range, and filters, so the baseline of 3 is appropriate.

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 ('Search') and resource ('performance') and enumerates the metrics returned (clicks, impressions, CTR, position), so it is more than a restatement of the name. It does not explicitly distinguish this tool from close siblings such as performance_overview, compare_periods, or query_segments, 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?

The phrase 'for any dimension combination, search type, date range and filters' implies this is the flexible raw performance-query tool, but it gives no explicit when-to-use guidance, prerequisites, or exclusions. It never names performance_overview or compare_periods as alternatives for summarized or comparative views, leaving the agent to infer routing.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, and the description usefully adds that notes persist 'for future chats'. However, it never discloses that the tool also supports a delete action, whether deletion is permanent, whether notes are scoped to a single property, or what a list call returns — significant omissions for a stateful store.

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 compact sentence with no filler and the core concept ('context saved with a property') up front. It is efficient but border-line under-specified rather than merely tight, and the trailing colon list of kinds reads as an enumeration rather than a purpose statement.

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 five-parameter, mutating, open-world tool with 40% schema coverage and no output schema, so the description carries real weight. It omits the action lifecycle (add vs list vs delete), what happens on delete, and what a list returns, leaving an agent unable to use it correctly for anything but a default list call.

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

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

Schema coverage is only 40%, but the description does add meaning for the hardest parameter by naming the note categories that correspond to the `kind` enum values. It gives nothing for `action` (list/add/delete), `note_id`, or `text`, leaving the create/delete workflow to be inferred from bare enum values.

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 conveys the resource (per-property notes/context) and the categories it stores (brand terms, migration dates, decisions, site changes), which maps to the `kind` enum. But it is phrased as a noun clause ('Context saved with a property') with no verb, so an agent cannot tell from the text that this tool lists, adds, and deletes notes, nor that 'list' is the default 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 explicit when-to-use guidance: nothing says to call this before `query_segments` for brand terms, or to check existing notes before recording a decision. The only routing hint ('brand terms used by query_segments') lives in the schema's `kind` description, not here, and no sibling tool is named as an alternative or complement.

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 and openWorldHint=true, so safety and external-dependency behavior are covered. The description adds useful scope detail (which subsystems are aggregated, that metrics are compared to a previous period), but says nothing about partial failures, missing data, or how many upstream calls are made per invocation.

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 dense sentence that front-loads the key framing ('one-call overview') and then lists the signal groups. No filler, though a fragment rather than a sentence and a comma-list that could be segmented for faster scanning.

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 composite read-only tool with no output schema, the description enumerates the major result sections, which is the essential information an agent needs to decide to call it. It stops short of indicating response shape or aggregation granularity, but nothing critical to invocation is missing.

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

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

Schema coverage is 100% and the schema itself explains the PT day window, the 490-day cap, the default of 28, and the precedence of start_date over days, plus accepted site formats. The description's 'vs previous period' phrase is consistent with those semantics, so no additional parameter explanation is needed for correct invocation.

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 composite resource ('one-call overview') and enumerates the contents: web + Discover performance vs previous period, sitemaps health, local indexing summary, robots.txt status. This clearly separates it from single-purpose siblings like sitemaps or robots_txt_check, though it never names the nearest alternative (performance_overview, multi_site_dashboard) explicitly.

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

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

Usage is implied rather than stated: 'one-call overview' suggests a first-pass/triage use, but there is no explicit when-to-use, when-not-to-use, or pointer to alternatives such as performance_overview or compare_periods. An agent must infer the slot from the enumerated contents.

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 and openWorldHint=true, so the safety profile is covered. The description adds value by disclosing the segmentation dimensions the tool computes, which is real behavioral context. However, it says nothing about aggregation, result limits (top_n), time-zone handling, or the brand_terms fallback to property notes.

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, and the segment list is the most information-dense part. The opening 'Queries split into' is slightly awkward phrasing but wastes no 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?

With seven parameters, no output schema, and a multi-dimensional aggregation result, the description should explain the return shape and how the dimensions are grouped. It also omits date-range behavior (days vs start_date/end_date, Pacific Time) and the brand_terms default, leaving the agent under-informed about a non-trivial report 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 71%, with top_n and search_type carrying no description at all. The description mentions no parameter by name — not brand_terms (which drives the branded/non-branded split), not search_type, not top_n — so it adds essentially no meaning beyond the schema and leaves the undocumented parameters doubly unexplained.

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 concrete analysis ('Queries split into...') and enumerates the actual segment dimensions: branded vs non-branded, question queries with specific languages, query length, results page, and chat-style fragments. An agent can tell this is a query-segmentation report rather than a raw performance pull. It stops short of naming a sibling such as performance_query as the alternative, so it doesn't reach 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 or when-not-to-use guidance and no mention of alternative tools. The agent must infer from the segment list that this is for query-intent analysis, but nothing says when to pick it over performance_query or find_opportunities.

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 and openWorldHint=true, so the agent knows this mutates state against an external system. The description adds the useful context that the URL set is derived from Search performance data, but says nothing about what the queue feeds into, whether re-queueing duplicates work, or any volume/rate implications of pulling up to 25k URLs.

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 the action first and the rationale second; nothing is wasted. It is arguably too terse rather than too long, but structurally sound.

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

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

For a five-parameter, state-mutating tool with no output schema, the description covers the source of the URLs but omits what happens after queueing, how the queued set relates to run_inspections, and any limits. Adequate to call it, not adequate to predict its 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?

Schema description coverage is only 60%, and the description adds no meaning for days, max_urls, search_type or min_impressions beyond the word 'impressions' loosely gesturing at the filter. With a moderate coverage gap and no compensating explanation of defaults or the date window, the description does little 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 ('Queue') and a precisely scoped resource ('every page that got impressions in Search'), which lets an agent distinguish it from queue_urls and queue_from_sitemaps by the URL source. It stops short of naming those siblings explicitly, so it is clear but not fully differentiated.

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

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

The parenthetical '(useful to inspect the pages Google actually shows)' gives a rationale for choosing this tool over other queueing tools, which implies the when-to-use case. However, it never states when NOT to use it or names the alternative queueing siblings, leaving the routing decision partly 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 declare readOnlyHint=false and openWorldHint=true; the description usefully adds that it fetches over the network (including nested indexes and .gz) and records per-URL sitemap provenance. It omits key behavioral facts for a state-mutating tool: whether the queue is replaced or appended, deduplication of already-queued URLs, and what happens when max_urls truncates the set.

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 dense sentence with the action and the provenance behavior front-loaded; no filler to remove.

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 three-parameter tool with no output schema, the description covers what it consumes and what it produces (a queued URL set with sitemap attribution). The remaining gap is queue semantics (replace vs append) and the downstream inspection step.

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 67%, with 'site' and 'sitemap_url' (including the 'default = every sitemap submitted in Search Console' behavior) already documented in the schema. The description adds no meaning for 'max_urls', which has no schema description and is the parameter most likely to cause surprise truncation given the claim of queuing 'every page URL'.

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?

Uses specific verbs and resources ('Download sitemaps (indexes, .gz) and queue every page URL for inspection'), so the agent knows exactly what the tool does. It never names a sibling (queue_urls, queue_from_performance, list_sitemaps) to contrast against, so 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?

The phrase 'queue every page URL for inspection' implies this is the seeding step before run_inspections, but no explicit when-to-use or when-not guidance is given. Nothing tells the agent whether to pick this over queue_urls or queue_from_performance.

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. The description usefully clarifies that the queue is 'local' and per-property, which softens the openWorld expectation, but it says nothing about duplicate handling, queue size limits, or what state the URLs enter until inspections run.

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 sentence with no waste, and the destination ('local inspection queue') is placed before any caveats. It is efficient, though its brevity borders on under-specification for a queue-mutating 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?

For a three-parameter enqueue tool with no output schema and adequate annotations, the definition is minimally sufficient. It leaves a gap around what happens after queuing and how the queue is drained, which an agent needs to sequence this tool correctly.

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

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

Schema coverage is 100%, so site formats, the URL array, and the 'label' default of 'manual' are all documented structurally. The description adds no meaning beyond that, contributing nothing about how label affects later filtering or whether URLs must be inside the property. Baseline 3 applies.

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

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

States a concrete verb and resource ('Add URLs') and a specific destination ('this property's local inspection queue'), which separates it from queue_from_sitemaps and queue_from_performance by implication of a manual, locally-supplied list. It stops short of naming the sibling queue tools, so differentiation is inferential rather than explicit.

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 at all. The description never tells the agent to prefer queue_from_sitemaps or queue_from_performance when the URLs originate there, nor that run_inspections must be called afterward to actually process the queue; only the word 'queue' hints at 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 declare openWorldHint=true and destructiveHint=false, and the description meaningfully extends this by disclosing the Googlebot user-agent emulation, the 500 KiB evaluation threshold, and the side effect of persisting results to history (consistent with readOnlyHint=false). It stops short of noting auth requirements, rate limiting, or what happens for a missing/erroring robots.txt, which would matter for a remote fetch.

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

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

One front-loaded sentence with the action first and the returned artifacts following as a compact enumeration. Every clause maps to a real output; nothing redundant or padded.

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

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

There is no output schema, so the description usefully enumerates what comes back, including the size-limit check and Google's own interpretation. For a one-parameter read-plus-history tool this is close to complete; only edge-case behavior (robots.txt missing, 4xx/5xx, blocked fetch) is left 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?

With a single parameter at 100% schema coverage, the schema already documents that host, URL, or sc-domain property is accepted. The description adds no formatting or normalization guidance beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Fetch robots.txt like Googlebot') and enumerates the concrete outputs (status, size vs 500 KiB, groups, Googlebot rules, sitemaps, syntax warnings, diff). It does not, however, distinguish itself from the closely named sibling robots_txt_check_property, and its mention of 'diff' and 'history' overlaps conceptually with robots_txt_diff and robots_txt_history.

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

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

Usage is only implied: an agent can infer this is for validating crawlability of robots.txt as Googlebot, versus robots_txt_test (live rule testing) or robots_txt_watch (ongoing monitoring). There is no explicit when-to-use statement, no exclusions, and no sibling is named as an alternative.

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 openWorldHint=true, destructiveHint=false, and readOnlyHint=false. The description adds useful operational scope: hosts are selected by Search traffic and Domain properties expand to all subdomains. It does not explain rate limits, permissions, result format, or the behavior implied by a 'check' tool not being marked 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 front-loaded sentence with no filler, and the parenthetical adds useful scope detail. The description is appropriately sized for this 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?

The description is adequate for a property-level diagnostic, but with no output schema it should explain what the check returns (per-host statuses, errors, or summaries) and how days and max_hosts constrain coverage. Those omissions leave gaps in result shape and practical limits.

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 67% schema description coverage, the baseline is 3. The description adds meaning to the site/property parameter by noting Domain-property subdomain coverage, but it does not explain days (how the traffic lookback is used) or max_hosts (the cap on hosts checked), and max_hosts has no schema description either.

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

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

The description uses a specific verb and resource ('Check robots.txt') and clearly states the scope: every host with Search traffic in the property, including subdomains of a Domain property. It is distinguishable from a single-host check, though it does not explicitly name the sibling robots_txt_check.

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 property-wide use case is implied clearly by 'every host that had Search traffic in the property,' but there is no explicit when-not guidance or routing to robots_txt_check for a single host/site. An agent can infer when to use it, but alternatives are not addressed.

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 and openWorldHint=true, so the safety profile is covered. The description adds that output is a unified diff and that inputs are historical check ids, but says nothing about diff size, truncation, or behavior when the two checks are identical. Adequate but not rich.

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

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

One tight sentence with the key qualifier (ids from robots_txt_history) placed where it is immediately visible. Nothing is wasted, though the sentence is so terse that a small amount of clarifying structure could have been added at no cost.

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 simple two-parameter read-only tool with no output schema, so the description does not need to explain return values. Combined with annotations, an agent has enough to invoke it correctly; only the direction semantics of from/to remain ambiguous.

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

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

Schema coverage is 0%, so the description must carry the load; it does clarify that both ids come from robots_txt_history, which is genuinely useful. However, it does not clarify the from/to directionality – whether the diff reads as changes from from_check_id to to_check_id.

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 operation and resource: a unified diff between two stored robots.txt checks. Pointing to robots_txt_history as the source of ids distinguishes it from robots_txt_check and robots_txt_test, though it does not explicitly say what the diff is used for.

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 phrase 'stored robots.txt checks' – you need prior checks to diff – and the parenthetical points to robots_txt_history for obtaining ids. There is no explicit statement of when to prefer this over robots_txt_check or robots_txt_history, nor any exclusion.

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 establish readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description usefully adds what the response contains (per-check fields and distinct versions with first/last seen), but says nothing about ordering, pagination behavior, or what happens when a host has no stored checks.

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 dense sentence that front-loads the primary return content and appends the version aggregation. No filler, though the parenthetical field list slightly crowds out the missing parameter guidance.

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

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

With no output schema, the description must explain return values, and it does list the per-check fields and the version summary. However, it leaves the limit parameter and the host-vs-URL input form unexplained, which are material gaps for a two-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%, so the description carries the full burden. It clarifies that host_or_url targets a single host, but it never explains that a full URL is also accepted, and it does not mention limit at all — not its default, its maximum, or what it caps (checks vs. versions).

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 specific resource (stored robots.txt checks) and the scope (one host), and it lists the fields returned plus the aggregated version view. It implicitly distinguishes itself from live-check siblings like robots_txt_check by emphasizing 'stored' history, though it never names an alternative explicitly.

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

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

Usage is only implied: the word 'stored' signals this is for retrospection rather than a fresh fetch, which contrasts with robots_txt_check and robots_txt_diff. There is no explicit when-to-use, when-not-to-use, or named-alternative 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 and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral context by stating it returns the deciding rule and line and follows Google's matching rules, though it does not explain live-fetch behavior or error cases.

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 core question and followed by the key return information. There is no unnecessary wording and the structure is immediately scannable.

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

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

For a read-only query tool with no output schema, the description covers the purpose, matching standard, and what the result contains (the deciding rule and line). It leaves some gaps around live versus stored checks and the show_content flag, but those are largely covered by the input 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 75%, with clear descriptions for url, check_id, and user_agent, so the schema carries most parameter meaning. The description adds only the notion of a crawler and Google's matching rules, and does not clarify show_content or stored-version testing beyond what the schema already provides.

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 question ('Is this URL allowed for this crawler?') and the resource being tested (URL against a crawler's rules). It also clarifies the matching standard ('Google's matching rules'), though it does not explicitly distinguish this from sibling tools like robots_txt_check or robots_txt_check_property.

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: test a single URL against a crawler's robots.txt rules using Google's matching semantics. However, there is no explicit guidance on when to use this versus robots_txt_check, robots_txt_check_property, or robots_txt_history, and no exclusions or prerequisites are stated.

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, and openWorldHint=true, so the safety profile is partly covered, but a false readOnlyHint on a polling tool is exactly the kind of thing that needs explanation. The description does add genuinely useful behavior the annotations cannot convey: the watch persists in the background and only advances while Claude Desktop is open. It stops short of saying what happens to accumulated history, how often checks actually fire, or that no version is captured while the app is closed.

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 sentence with no filler, and the most important qualifier, the Desktop-only background nature, is embedded early rather than buried. It is efficient, though it burns its brevity on runtime context instead of the operation controls.

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

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

There is no output schema and no annotation nuance to lean on, so the description carries the full burden for a three-parameter, stateful, three-mode tool. It omits what each action returns, whether watches survive restarts, and how the gathered history relates to robots_txt_history and robots_txt_diff.

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 does not mention any of the three parameters. Nothing explains that 'action' toggles add/remove/list, what form host_or_url takes, or that interval_hours defaults to 24 and is capped at 168. With low coverage 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 states a specific verb and resource: repeatedly polling a host's robots.txt to accumulate version history, with the notable scoping constraint that it runs only while Claude Desktop is open. It is clear on its own but never names or contrasts with the siblings an agent would naturally confuse it with, such as robots_txt_check, robots_txt_history, or robots_txt_diff.

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

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

Usage is only implied: an agent can infer this is for setting up recurring monitoring rather than a one-off fetch, and the parenthetical gives the runtime condition. There is no explicit 'use this instead of robots_txt_check when...' guidance and no statement about when watching is unnecessary.

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 readOnlyHint=false and openWorldHint=true already declared, the description adds genuinely useful behavioral context the annotations cannot carry: the 2,000/day and 600/minute per-property quota ceilings that govern whether a call will succeed. The queue ordering (never-inspected first, then stale) further clarifies what actually happens. It stops short of saying the call consumes quota against a shared budget or that results may be partial when the time budget elapses.

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

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

Two sentences, front-loaded with the action and mode selection, then the quota constraint. No filler and nothing structurally out of order.

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, no-output-schema tool with an open-world flag and real quota cost, the description covers mode selection and rate limits adequately. It omits what the caller gets back from an inspection run (per-URL verdicts, coverage state, errors) and whether a time-budget expiry yields resumable partial results, both of which an agent needs to plan around.

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

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

Schema coverage is 75%, so the schema already documents `urls`, `top_pages`, `stale_days`, `recrawled_since`, and `time_budget_seconds`. The description usefully explains the queue default ordering that `stale_days` governs, but says nothing about `max_urls`, `concurrency`, or the interaction between the mode-selecting parameters, leaving the remaining gap unfilled.

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 opens with a specific verb and resource ("Inspect URLs now") and enumerates three operating modes: the queue, an explicit URL list, or top pages. That distinguishes it from the single-URL sibling `inspect_url`, but no sibling is named explicitly, so differentiation is inferred rather than stated.

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

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

The three modes imply when to use each (pass `urls` for an explicit list, `top_pages` for top pages, nothing for the queue), which maps loosely onto the parameters. However, there is no guidance on precedence when `urls` and `top_pages` are both supplied, no exclusions, and no pointer to alternatives such as `queue_urls` or `inspect_url` for queuing versus executing.

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?

Beyond readOnly/openWorld annotations it discloses two non-obvious behaviors: that results include share of clicks and a comparison against the previous period, and that domain (sc-domain) properties are split per host rather than aggregated. It does not say how truncation via top_n affects the delivered shares, which is the remaining behavioral 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?

Two compact sentences, front-loaded with the metric and entity, no filler. The closing sentence about domain properties is terse to the point of being slightly cryptic about what 'split per host' means for the rows returned.

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 9-parameter tool with no output schema, the description covers the core metric but omits the default window, how top_n interacts with reported shares, and whether level or prefixes takes precedence. Enough to call it, not enough to call it correctly on the first try in edge cases.

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

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

Schema coverage is 78% and the schema already explains level, prefixes, dates and days well. The description adds the conceptual link between 'section' and the level/prefixes parameters, which helps an agent choose between them, but it says nothing about top_n, compare_previous, or precedence rules. Baseline 3 given the strong schema.

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

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

States a specific resource and scope: performance aggregated per site section, either a URL folder depth or custom prefixes, with click share and period-over-period change. That is clearly distinct from query-level or page-level tools, but no sibling (performance_query, performance_overview, query_segments) is named, so 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 only implied by the aggregation unit ('per site section') – an agent can reason that this is the tool for folder-prefix rollups, but nothing states when to prefer it over performance_overview or compare_periods. No exclusions or prerequisites are given.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds real value by disclosing the breadth of what is checked (credentials, DB, queues, jobs, robots.txt watches, quota), which signals this is a composite probe that may touch multiple subsystems. It says nothing about latency, whether checks are live or cached, or how failures are surfaced, leaving behavioral gaps.

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

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

One dense line, zero filler, scope front-loaded with 'Server health' before the enumeration. The trade-off is that it is a bare fragment rather than a complete sentence, so the agent must infer the verb ('report/check') itself.

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

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

For a parameterless diagnostic with no output schema, the description tells the agent what areas are inspected but not what a result looks like (per-component pass/fail, degraded states, quota numbers) or how to react to a failure. That leaves a meaningful gap, though the component list is enough to justify calling it during troubleshooting.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond what the schema provides; baseline 4 applies. The enumerated list is a report of coverage, not parameter meaning, but no compensation is needed.

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

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

The phrase 'Server health' plus an enumerated list of subsystems (credentials, local database, inspection queues, background jobs, robots.txt watches, quota use) makes the resource and scope unambiguous — an agent knows this is an aggregate diagnostic status read. It is a noun fragment with no verb and draws no boundary against siblings such as check_alerts or inspection_job, which keeps it out of 5 territory.

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 at all — no statement like 'call first when tools fail' or 'use instead of check_alerts for backend health'. The list of subsystems only implies diagnostic usage; it never routes the agent relative to the many nearby inspection and robots.txt siblings.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuine value by disclosing the output taxonomy and that losses are split into impression loss vs CTR loss, but says nothing about ordering, result limits, cost, or how the comparison window is anchored beyond 'previous period'.

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 dense sentence that front-loads the resource and scope before the diagnostic detail; nothing is redundant. It is jargon-heavy enough that a first-time reader may need a second pass, but every clause conveys information.

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

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

With 10 parameters and no output schema, the description does well to enumerate the diagnostic categories the tool returns, partially substituting for a return-value spec. However, it leaves gaps on result ordering, how min_clicks_prev and top_n interact with the drop ranking, and what the per-drop explanation payload looks like.

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

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

Schema description coverage is 70%, so most parameters are already documented. The description indirectly explains the purpose of position_threshold (ranking loss) and the demand/min_clicks filtering, but it never addresses top_n, explain_top, dimension, or search_type behavior. Baseline 3 is appropriate when the schema carries most of the burden.

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 ('pages/queries that lost clicks vs the previous period') plus the diagnostic taxonomy (ranking loss, CTR drop, demand drop, disappeared) and the exact decomposition of click loss. An agent can distinguish this from generic period comparison or performance listing tools without opening the schema.

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

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

The framing as a loss-diagnosis tool implies when to use it, but there is no explicit guidance on when to prefer it over siblings such as compare_periods, content_decay, find_opportunities, or performance_query. No exclusions or prerequisites are stated.

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 and openWorldHint=true, so the safety profile is covered. The description adds that this hits Google again (a live external call), but omits the key behavioral outcome: what happens on a mismatch, whether a failed verification raises an error, and what tolerance_pct does to the result.

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 an illustrative example and no filler. It is efficient, though the single-sentence brevity is part of why behavioral and parameter detail are missing.

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

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

Wrong — see below.

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 67% and the description adds no parameter meaning at all — it never mentions site, metric, expected, or tolerance_pct. The two most consequential params (expected and tolerance_pct) have no description in the schema either, so the verification-matching logic is 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 states a specific verb and resource: re-query Google to confirm a number. The example ('this page got 500 clicks') makes the intent concrete. It does not name the sibling it differs from (performance_query), so an agent must infer the distinction from the name 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?

It gives a usage context — verify before presenting a number — but never says when not to use it or which alternative to call instead (e.g. performance_query for exploration). The trigger condition is implied rather than stated as a 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?

The description usefully explains the anomaly of readOnlyHint=false for a reporting tool: it is 'saved as a Markdown file', so the agent understands the write is a local artifact, not a mutation of the site — this is real added value beyond the annotations. It does not disclose where the file lands, what the filename/path convention is, or whether an openWorldHint=true call of this breadth is slow or rate-limited, which are the traits an agent most needs here.

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 sentence, front-loaded with the payload ('Full report in one call') and followed by an enumerated section list. The parenthetical is long but every item earns its place by telling the agent what questions the report answers, and there is no filler.

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

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

For a broad aggregate tool with no output schema, the description is reasonably complete: the agent knows exactly which ten analyses come back and that the deliverable is a Markdown file. Missing pieces are where the file is saved, how to retrieve it later, and how 'days'/'top_n' shape the output, which keeps it below a 5.

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 33% — only 'site' is documented — and the description adds nothing about 'days' (the reporting window, 7–90, default 28) or 'top_n' (3–50, default 10). Given that 'top_n' clearly governs how many rows appear in each section and the description lists ten sections that will be truncated by it, this is a meaningful gap the description should have closed.

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 ('full report') and enumerates its ten sections (performance, alerts, drops, quick wins, content gaps, decay, cannibalisation, sitemaps, indexing, robots.txt), which implicitly distinguishes it from the granular siblings like performance_query, check_alerts, and content_decay. The verb is only implied ('in one call ... saved as a Markdown file') rather than stated outright, and the tool never says what data source it operates on, so it stops short of a 5.

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

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

'Full report in one call' hints that this is the aggregate alternative to calling many section tools individually, which is useful routing signal. However, there is no explicit 'use this when...' statement, no mention of when a narrower sibling like section_performance or find_opportunities would be preferable, and no cost/latency caveat for an agent deciding between one broad call and several focused ones.

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