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

Annotations already cover safety (readOnly, idempotent, non-destructive, openWorld). The description adds one useful behavioral fact: results depend on the property exposing the searchAppearance dimension, so calls may yield empty or partial data. It says nothing about how the trend comparison is computed, pagination behavior, or error handling, but with annotations present a 3 is fair.

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. It is efficient, though it is arguably too terse given the tool's 10-parameter comparison 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?

An output schema and fully documented parameters reduce the burden, and the description covers purpose and an availability caveat. However, the core mechanic of this tool – comparing currentDateRange against previousDateRange to derive trend deltas – is never mentioned, which is a meaningful omission for a 'trends' tool even if inferable from 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% across all 10 parameters, including enums, defaults, and nested date ranges, so the schema carries the parameter burden. The description adds no parameter-specific detail beyond referencing the searchAppearance dimension (which is not itself a parameter and connects loosely to includePages). 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 (Analyze) and resource (structured data / rich-result trend signals) and names the underlying dimension (searchAppearance) that distinguishes it from siblings like gsc_query_search_analytics or gsc_compare_search_types. It does not explicitly say how it differs from those siblings, so it stops short of a 5.

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

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

The only conditional statement is 'when GSC exposes it,' which is an availability caveat rather than guidance on when to choose this tool over gsc_query_search_analytics, gsc_compare_search_types, or gsc_find_losses_gains. No when-not-use or alternative routing is provided.

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/idempotent/non-destructive, so the description correctly adds context they cannot: sequential conservative execution, normalized output, and the 2000 requests/day/property quota. It stops short of stating what normalization means or how partial failures surface (though continueOnError in the schema covers 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?

Two sentences, zero waste: behavioral scope first, hard quota constraint second. Nothing to trim and the constraint is front-loaded.

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

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

With an output schema, complete parameter descriptions, and safety annotations, the description only needs to carry quota and execution behavior, which it does. Slightly incomplete on how errors are aggregated, though continueOnError's schema description covers that ground.

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 four parameters (urls, siteUrl, languageCode, continueOnError) are already documented in the schema. The description adds only the quota rationale, which partially overlaps the urls maxItems note, so baseline 3 applies.

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

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

States a specific verb and resource ('Inspect multiple URLs') and the batching scope, which inherently separates it from the single-URL sibling gsc_inspect_url. It does not name that sibling explicitly, so differentiation is implied 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 word 'multiple' and the 10-URL cap imply batch usage, but the description never says when to prefer this over gsc_inspect_url or gsc_plan_large_site_sampling, nor when not to use it. Usage is inferable only from the tool name and quota note.

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, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The phrase 'simple tokens and intent signals' usefully signals that clustering is heuristic/token-based rather than semantic, but nothing is said about deriving brand terms by default, how many API rows are fetched, or cost/rate implications of a wide date range.

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 verb first and no filler; it earns its place but is thin for a nine-parameter tool with nested objects and enums.

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

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

With a fully documented schema and an output schema present, the mechanical gaps are filled elsewhere. What remains missing is the routing context an agent needs: what the cluster output is good for and how it relates to its siblings, which matters given nine optional parameters and nested date/rule objects.

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 carries parameter meaning and a baseline of 3 applies. The description's mention of brand/non-brand and category tokens loosely maps to brandTerms and categoryRules, but adds no syntax or behavioral detail beyond what the schema says.

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 ('Cluster') and resource ('Search Console queries') and names the dimensions that define the clusters (brand/non-brand, question, category, topic tokens). No sibling tool does clustering, so it is distinguishable, though the description never states the tool is not a plain query listing like gsc_query_search_analytics.

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

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

There is no statement of when to use this instead of gsc_query_search_analytics, gsc_compare_search_types, or any other sibling, and no prerequisites or exclusions. The agent must infer from the name alone that this is the aggregation step after pulling query 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 readOnly, idempotent, non-destructive and openWorld, so the safety profile is fully covered. The description adds nothing behavioral beyond re-listing the enum values that already appear in the schema: no mention of per-surface data limitations (e.g. Discover/News coverage constraints), cost/rate considerations of querying up to six surfaces, or that overlapping surfaces must not be summed.

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 verb and resource leading, no filler. It loses a point only for redundantly enumerating all six surface names that the schema enum already specifies.

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 rich annotations, a full output schema, and 100% schema coverage, most burden is carried by structured fields. However, for a multi-surface comparison tool the description should at least note that results are per-surface and not additive, and when to choose it over single-surface analytics queries.

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%, including the key caveat that 'each surface is queried separately; do not sum overlapping surfaces'. The description merely repeats the surface names already present in the schema enum and adds no syntax, defaults, or defaults-override guidance.

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 (compare) and resource (Search Console search types), and enumerates the surfaces involved. An agent can distinguish it from gsc_query_search_analytics, but the description never explicitly says how it differs from that sibling (presumably single-surface querying).

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

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

The word 'compare' implies the use case (side-by-side surface performance), but there is no explicit when-to-use, when-not-to-use, or named alternative. Nothing tells the agent to prefer gsc_query_search_analytics for a single surface instead.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the description's only remaining burden is behavioral detail it does not supply — no mention of how candidates are ranked, what the result ordering is, whether low-impression queries are dropped, or any data-volume caveats. It essentially restates the purpose and stops.

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

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

A single front-loaded sentence with zero filler or redundancy. It is efficient, though its brevity borders on under-specification for a nine-parameter analytical 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?

An output schema exists and all nine parameters are documented, so the essentials are covered. For a multi-parameter heuristic analysis tool, however, the description leaves the detection logic and result semantics entirely to the schema, which is the minimum viable level.

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 minPages, minImpressions and maxTopPageClickShare is fully documented in the schema; baseline 3 applies. The description adds no interpretation of thresholds or how they interact (e.g. how minPages and maxTopPageClickShare jointly define a candidate).

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

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

Names a specific verb ('detect') and a precise analytical concept ('queries where multiple pages compete for clicks/impressions'), which is unmistakably keyword cannibalization analysis rather than a raw query dump. It is distinguishable from gsc_query_search_analytics in substance, though it never names a 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?

There is no when-to-use, when-not-to-use, or alternative routing guidance. The agent must infer from the one-sentence purpose that this is the analysis tool versus gsc_query_search_analytics or gsc_cluster_queries, with no stated conditions or prerequisites.

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, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds that the tool returns deltas rather than raw rows, which is useful, but it says nothing about cost/latency of fetching two periods, topN/limit interaction, or how previousDateRange is defaulted.

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 sentence, front-loaded with the comparison action and the returned metrics, with no filler. It is efficient, though the brevity leaves important behavioral details unstated.

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

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

This is a complex tool: 10 parameters, nested current/previous date range objects, a preset fallback, and topN vs limit semantics. Given that surface, a single sentence does not tell the agent how the two periods are constructed, what the previous-period default means, or how ranking/filtering interact, leaving meaningful gaps despite the presence of an output schema and strong annotations.

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

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

Schema description coverage is 100% and each of the 10 parameters (including nested date-range objects) is documented in the schema. The description contributes no additional parameter meaning, so the baseline of 3 applies.

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

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

States a specific verb ('Compare') and resource ('query or page performance') and names the exact outputs ('click/impression/CTR/position deltas'). It is clear enough to distinguish from gsc_query_search_analytics, but it never explicitly contrasts itself with siblings like gsc_compare_search_types, 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?

The only guidance is the implicit 'use this to compare two periods'. There is no statement of when to prefer it over gsc_query_search_analytics or gsc_compare_search_types, no mention of prerequisites, and no hint about how to choose between datePreset and the custom range objects.

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, idempotentHint and destructiveHint=false, so safety is covered. The description adds a small amount of behavioral context — that the detection works by scanning recent daily rows — but says nothing about cost, API call volume, rate limits, or what happens when no data is found within the lookback 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?

A single front-loaded sentence that leads with the outcome and ends with the mechanism; there is no filler and nothing is buried.

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?

An output schema exists, so return values needn't be explained, and read-only/idempotent behavior is covered by annotations. What's missing is the operational context an agent still needs: which counts as valid output when no data is found, and how this differs from the other freshness-flavored sibling.

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 siteUrl, searchType and lookbackDays (including the 3–30 bound) are fully documented in the schema. The description's reference to "recent daily rows" loosely gestures at lookbackDays but adds no format or defaulting 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?

States a specific verb ("detect") and a precise resource/outcome ("the most recent date with Search Analytics data"), plus the mechanism ("querying recent daily rows"). That is enough to distinguish it from analytics-query siblings, though it never names the similarly-titled gsc_monitor_indexation_freshness, which an agent could easily confuse it with.

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

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

No when-to-use guidance at all: it doesn't say to call this before gsc_query_search_analytics to avoid querying stale dates, nor when to prefer gsc_monitor_indexation_freshness instead. The only usage context is implicitly inferred from the word "detect".

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, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds that the response includes the caller's permission level and maps to the read-only sites.get method, which is useful context beyond the structured fields, but says nothing about failure modes for inaccessible properties.

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 sentence, front-loaded with the verb and resource; nothing is wasted. The trailing parenthetical '(read-only sites.get)' is slightly cryptic but adds the API mapping cheaply.

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 an output schema, full parameter documentation and annotations covering safety, a single sentence stating what is fetched and what distinguishes the result is close to sufficient. Only the relationship to the sibling listing tool 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?

Schema coverage is 100% and the single siteUrl parameter already documents format examples and the GSC_SITE_URL fallback. The description contributes no additional parameter meaning, so baseline 3 applies.

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

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

Names a specific verb and resource ('Get one Search Console property') plus the returned attribute ('exact permission level'). The word 'one' implicitly contrasts with the sibling gsc_list_sites, but that sibling is never named, leaving the differentiation to inference.

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

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

Usage is only implied: an agent can infer this is the single-property lookup versus gsc_list_sites for enumeration, but there is no explicit when-to-use or when-not-to-use guidance and no prerequisites 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description's enumeration of returned fields (type, fetch state, warnings/errors, totals) adds a little context, but with an output schema present it is largely redundant and adds nothing about auth, rate limits, or error behavior.

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 resource, the keying parameter, and the payload all in order, and no filler. Nothing in it could be cut without losing information.

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

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

For a two-parameter read tool with full schema coverage, an output schema, and complete annotations, this covers the essentials. The remaining gap is failure/not-found behavior and how it relates to the sitemap-health sibling, which is minor for a simple lookup.

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 are already documented, including the GSC_SITE_URL fallback for siteUrl. The description's "by full feed path" reinforces that the required path must be the exact submitted URL, but adds no new semantics; 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?

Specific verb plus resource ("Get one submitted sitemap") scoped by "full feed path", which implicitly separates it from the sibling gsc_list_sitemaps. It stops short of naming the alternative, but an agent can still tell the single-item fetch apart from the list operation.

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: fetch details for a single sitemap once you know its feed path. There is no explicit guidance on when to prefer this over gsc_list_sitemaps or gsc_get_sitemap_health, and no note about what happens if the sitemap was never submitted.

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, idempotentHint, non-destructive, and openWorld, so the safety profile is fully covered. The description adds that the result is an aggregate 'enriched' summary with status totals and warnings/errors, which is useful context, but it does not state anything about freshness/caching, rate limits, or what happens when no sitemap 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?

A single, front-loaded sentence with no filler. The payload contents are listed compactly and 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?

The tool has one optional, fully documented parameter, rich annotations, and an output schema, so the description does not need to explain return values. The missing piece for a 19-sibling toolset is routing context: why choose this over the other sitemap tools, which the description leaves unaddressed.

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

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

Schema description coverage is 100%: siteUrl is documented in the schema with an example format and the GSC_SITE_URL fallback. The description adds nothing about siteUrl, so the baseline 3 for high-coverage schemas 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 ('Return an enriched read-only sitemap health summary') and enumerates the payload contents (status totals, submitted/indexed counts, warnings, errors), so the agent knows exactly what it gets. It does not, however, distinguish itself from sitemap siblings such as gsc_list_sitemaps, gsc_get_sitemap, or gsc_track_sitemap_deltas.

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

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

There is no guidance on when to call this instead of gsc_list_sitemaps, gsc_get_sitemap, or gsc_track_sitemap_deltas, despite four sitemap-related siblings. The agent must infer the choice from the description's mention of 'health summary' and 'totals' 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 readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description still adds real value by disclosing that tokens are never exposed in output, which is a security-relevant behavior an agent would otherwise have to discover empirically.

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; the action verb leads and the enumerated checks follow immediately. Nothing needs trimming.

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

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

An output schema exists, so return details needn't be spelled out, and the single parameter is fully documented. The one remaining gap is the operational framing — when in a workflow an agent should call this and how to react to a failed check.

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 optional parameter at 100% schema coverage, the schema fully documents siteUrl and its GSC_SITE_URL fallback. The description only obliquely gestures at this via 'configured default site', adding little semantic meaning beyond the schema.

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

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

Specific verb (verify) plus a concrete list of resources checked: read-only authentication, visible properties, default site, permission levels. It is distinguishable from data-querying siblings like gsc_query_search_analytics or gsc_list_sites, though it never names a sibling to draw the contrast 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 name and the word 'Verify' — an agent can infer this is a diagnostic/setup tool, but the description never says to run it before other calls, what to do on failure, or when gsc_list_sites would be the better choice.

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, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds genuinely new context: statelessness ("without storing state") and the triage output shape (alert/review/ok), which tells the agent what to expect from a monitoring call. The 10-URL cap is repeated from the schema rather than added.

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

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

Two sentences, front-loaded with read-only scope and the batch limit, with nothing redundant. Every clause carries 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?

An output schema exists, so return values need not be explained, and annotations cover safety. What is missing is the core mechanic: that assessments are produced by comparing entries against expectedVerdict/expectedCanonical/expectedCoverageState. Useful but slightly incomplete for an expectation-checking 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 100%, so the schema already documents urls, siteUrl fallback to GSC_SITE_URL, languageCode, and continueOnError. The description adds no meaning beyond it, so the baseline 3 applies; notably it never mentions the expectedVerdict/expectedCanonical comparison fields that drive the assessment.

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 (inspects) and resource (URL Inspection watchlist of critical URLs) and names the output vocabulary (alert/review/ok assessments). It does not explicitly differentiate itself from close siblings like gsc_inspect_url or gsc_bulk_inspect_urls, so the agent must infer that this is the expectation-driven variant.

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?

"For critical URLs" and "without storing state" imply when to reach for it, but there is no explicit when-not guidance or pointer to gsc_inspect_url / gsc_bulk_inspect_urls for other cases. The agent is left to infer the boundary between this and the bulk inspection 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 readOnly, idempotent, openWorld and non-destructive, so the description's main contribution is the 2000-requests/day/property quota — a real rate limit not present in structured fields. It stops short of noting what happens for a URL not owned by the property or that inspection can be slow/queued.

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: purpose first, operational constraint second. No filler, and the quota caveat is placed where an agent will see it before calling.

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?

An output schema exists, so return values need not be explained, and the description covers what is inspected plus the quota constraint. Only the single-vs-bulk routing against gsc_bulk_inspect_urls is left unaddressed for a network-bound, quota-limited 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 100%, and the schema already documents url, siteUrl (including the GSC_SITE_URL fallback) and languageCode. The description adds nothing about parameter 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?

Specific verb (Inspect) plus resource (URL) and it enumerates the exact facets returned: indexing status, crawl info, mobile usability, AMP, rich results. It does not distinguish itself from the sibling gsc_bulk_inspect_urls, so an agent must infer single-vs-bulk from the names alone.

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

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

Usage is only implied by the singular 'a URL' and by the stated daily quota, which hints that repeated single calls are expensive. It never names gsc_bulk_inspect_urls as the alternative or states a condition such as 'for more than a few URLs, use bulk'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds some behavioral value by noting that results include processing status and submitted/indexed counts, but it does not discuss permissions, rate limits, or pagination behavior—gaps that are somewhat mitigated by the annotations and the presence of an output schema.

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

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

The description is a single, front-loaded sentence that states the resource and the data returned without any filler. Every phrase contributes directly to the tool's purpose.

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

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

Given the rich annotations, 100% schema coverage, and an existing output schema, the description is nearly complete for an agent to invoke the tool correctly. The main missing piece is sibling differentiation, which prevents a full 5, but no critical call-time information is absent.

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

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

Schema description coverage is 100%, so both siteUrl and sitemapIndex are fully documented in the input schema. The description implies a property-scoped list but adds no syntax, format, or fallback details beyond what the schema already provides. A baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description uses a specific verb ('List') and resource ('sitemaps submitted for a Search Console property'), so the core purpose is immediately clear. However, it does not distinguish this tool from siblings such as gsc_get_sitemap, gsc_get_sitemap_health, or gsc_track_sitemap_deltas, leaving the agent to infer which one to call.

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 states what the tool lists but gives no explicit guidance on when to use it versus alternatives like gsc_get_sitemap for a single sitemap or gsc_get_sitemap_health for health metrics. No exclusions or contextual triggers are provided.

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, idempotentHint, and non-destructive behavior, so the safety profile is covered. The phrase 'accessible with the current credentials' usefully signals that results are permission-scoped, but nothing is said about pagination, result limits, or how many properties are returned.

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

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

A single front-loaded sentence with no filler; the scope qualifier comes after the core purpose where it belongs. Nothing could be removed without losing meaning.

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?

An output schema exists and no parameters are required, so the description carries little burden and covers what it must. The only missing piece is a hint about what the listing contains (site URLs and permission levels), which would aid an agent's next 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?

The tool takes zero parameters, so the baseline applies and there is no parameter semantics to explain. The description does not needlessly describe nonexistent inputs.

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

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

States a specific verb (list) and resource (Google Search Console properties) with scope 'accessible with the current credentials'. It implicitly contrasts with sibling gsc_get_site (single property) but never names it explicitly, so sibling differentiation relies on inference.

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

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

Usage is implied: this is the discovery call to enumerate available properties before calling per-site tools. There is no explicit when-to-use statement, no mention of prerequisites, and no named alternative such as gsc_get_site for a known site.

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, idempotentHint, and non-destructive behavior, so the description does not need to restate safety. It adds some context by calling the URL Inspection portion optional and 'small', matching the schema's quota-protection limit, but it does not explain operational behavior such as how the three data sources are combined or whether failures in one section affect the snapshot.

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

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

The description is a single front-loaded sentence with no filler. It efficiently lists the three main outputs an agent gets from the call.

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

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

The tool has six optional parameters, rich schema descriptions, annotations, and an output schema, so much of the required context is carried by structured fields. However, for a composite monitoring tool surrounded by more specific siblings, the description should do more to explain why an agent would use this snapshot instead of calling the individual data-freshness, sitemap, and URL-inspection 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 description coverage is 100%, so all six parameters are already well documented in the input schema. The description adds only the notion of an optional small inspection sample, which lightly reinforces inspectUrls but does not add meaning beyond the schema for siteUrl, searchTypes, lookbackDays, languageCode, or freshnessLagWarningDays.

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: a monitoring snapshot covering Search Analytics freshness, sitemap indexation totals, and an optional URL Inspection sample. That is clear enough to distinguish it from generic tools, but it does not explicitly contrast itself with siblings such as gsc_get_data_freshness, gsc_list_sitemaps, or gsc_inspect_url.

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 'monitoring snapshot' implies a monitoring use case, but there is no explicit guidance on when to choose this tool over the many sibling tools that cover its individual components. No prerequisites, exclusions, or alternatives 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, idempotentHint=true and destructiveHint=false, so 'read-only' largely restates structured data. The description does add the useful note that the plan is derived from sitemap risk plus Search Analytics performance, but skips quota/cost context (inspection calls consume provider quota) that the schema buries in one parameter.

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

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

A single front-loaded sentence with no filler, and the key qualifier ('read-only ... sampling plan') appears immediately. Slightly wasteful in repeating the read-only trait already carried by annotations.

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

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

With 100% schema coverage, an output schema, and annotations covering safety, the description only needs to frame the tool's role, which it does. The remaining gap is that it doesn't clarify the plan's outcome or how objectives shape the recommendation, but the output schema can carry that.

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 one of the 9 parameters is already documented, which sets the baseline at 3. The description only loosely gestures at parameters by naming 'sitemap risk signals' and 'page performance', adding little beyond the schema's own objectives and staleSitemapDays docs.

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: 'build' a 'read-only URL Inspection sampling plan for large sites', and names the two input signal families (sitemap risk, Search Analytics performance). It stops short of explicitly distinguishing it from the inspection-execution siblings (gsc_inspect_url / gsc_bulk_inspect_urls), so an agent must infer that this only plans rather than inspects.

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 context is implied by 'for large sites' and by the input signal names, but there is no explicit when-to-use, when-not-to-use, or named alternative such as gsc_bulk_inspect_urls for actually running inspections. The planning-vs-execution boundary is left to inference.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds the metric set it returns, but says nothing about GSC row caps, quota/rate-limit behavior, or how autoPaginate interacts with limit, all of which matter semantically for this 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 sentences, front-loaded with the action and the return shape, with the discovery pointer last. No filler or repetition of the title.

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 14 parameters, nested filter objects, and an output schema, the short description is defensible because the schema is fully documented and return values are covered by the output schema. The one real gap is guidance on dimension/metric compatibility, which is deferred entirely to the gsc:// resources rather than summarized.

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%, including bounds, defaults, enum meanings, and the aggregationType compatibility constraints, so the schema carries the burden. The description adds no parameter-level meaning beyond redirecting to the gsc:// resources, which is the baseline-3 case.

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 (query Google Search Console Search Analytics) and enumerates the returned metrics and supported breakdown dimensions, so an agent knows exactly what data it gets. It does not name any sibling to contrast with (e.g. gsc_find_losses_gains or gsc_compare_search_types), so differentiation is left implicit.

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 a pointer to gsc://metrics, gsc://dimensions, gsc://filters, and gsc://compatibility for valid fields and compatibility rules, which is genuinely useful for a tool with 6 enums and cross-field constraints. There is no statement of when to choose this tool over the many analysis siblings, and no exclusions or prerequisites.

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/idempotent/non-destructive, so the bar is lower, but the description still adds meaningful context: the comparison is stateless and depends on an agent-supplied baseline, meaning the server stores nothing between calls. That goes beyond the annotation set and shapes invocation behavior. It stops short of describing the delta output shape, but an output schema 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?

Two sentences, zero waste, with the read-only stateless nature front-loaded before the mechanism. Nothing 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 an output schema, rich annotations, and full schema coverage, the description is nearly sufficient. The one omission an agent might want is the first-run behavior (empty default baseline returns a full snapshot), which is only inferable from the schema default.

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 four parameters (including baseline, includeUnchanged, minAbsIndexedDelta) are already documented. The description only reinforces that the baseline is agent-provided; it adds no syntax or format detail beyond the schema, so baseline 3 is correct.

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 chain (fetch current snapshot, compare to baseline) and a clear resource (sitemap deltas). It's distinguishable from gsc_list_sitemaps and gsc_get_sitemap_health by the comparison framing, though it doesn't name 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?

'agent-provided baseline' implies this is a repeat-call tool where the prior snapshot output is fed back in, which is useful implied usage. However, it never says when to pick this over gsc_get_sitemap_health or gsc_list_sitemaps, nor what happens on a first call with no baseline.

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, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds the useful nuance that the tool validates rather than executes, but it is silent on what a validation result looks like behaviorally (does an invalid combo raise an error or return a report?), and the presence of an output schema offsets the need to explain returns.

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

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

A single front-loaded sentence with no filler; the purpose and the pre-execution timing are both stated immediately. It is perhaps too terse for the behavioral gaps it leaves, but as structure it is efficient.

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

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

The tool is simple and both the schema and an output schema are rich, so the description does not need to carry much. Still, for a validation tool it leaves the key questions open: what is checked, whether invalid combinations return errors or warnings, and whether it is a required predecessor to the query 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 100% and all three parameters (dateRange, dimensions, searchType with enum) are documented in-schema, so the baseline of 3 applies. The description adds no format or constraint detail, and it mentions 'metric' as part of the validated combination even though no metric parameter exists — a small inconsistency that the schema silently corrects.

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 (validate) plus the resource concept (metric/dimension/search type combination), and the phrase 'before executing it' hints that this is a pre-flight check rather than a data-fetching call. It does not name the sibling it precedes (gsc_query_search_analytics), so sibling differentiation is implicit 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?

'Before executing it' implies the usage window (pre-flight to an actual query), which is useful, but it never explicitly names gsc_query_search_analytics as the tool being validated for, nor does it say what to do when validation fails or whether this step is optional.

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