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

Annotations already fully cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the description only needs to add operational context. It does so with the write-flag gate, which is exactly the kind of auth/environment prerequisite the annotations cannot express and which will cause a call to fail if unmet. What remains undisclosed is failure behavior for an invalid sitemap URL, which is a modest 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 short sentences with zero filler, and the action is front-loaded ahead of the prerequisite. Every sentence 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?

For a simple two-parameter tool with full schema coverage and no nested objects, the definition gives an agent enough to invoke it correctly and to know the write flag is required. The one gap is that, with no output schema, nothing is said about what a successful submission returns or how failures surface.

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

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

Schema description coverage is 100% and both parameters already carry rich documentation, including that site_url must come from wsp_list_websites_gsc and the domain-vs-URL-prefix distinction. The description adds no parameter meaning beyond what the schema provides, 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 ('Submit or resubmit a sitemap') and the 'or resubmit' phrasing clarifies that the tool covers both first-time and repeat submissions. It is clearly distinct from siblings like wsp_show_sitemap_gsc and wsp_remove_sitemap_gsc by verb, 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?

Usage is implied by 'Submit or resubmit', and the description adds a hard precondition ('Requires WSP_ALLOW_WRITES=true') that an agent must satisfy before calling. It stops short of stating when to prefer this over alternatives such as verifying an existing sitemap with wsp_show_sitemaps_gsc.

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 this a non-read-only, idempotent, non-destructive, open-world operation, so the description's remaining job is small. It does add genuinely useful context beyond them: the WSP_ALLOW_WRITES=true feature gate, which the agent needs to know before calling. It doesn't mention ownership verification or what comes back, which keeps it from 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?

Two short sentences with no filler; the action comes first and the constraint follows. It is appropriately sized for a one-parameter tool, though the header largely restates 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?

For a simple single-parameter mutation with a fully documented schema and no output schema, the description covers the core mechanics and the write gate. It omits what happens after the property is added (verification requirement) and any note that results are visible via wsp_list_websites_gsc, leaving a modest 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 single parameter's description already spells out exact-match URL forms and the sc-domain: prefix. The tool description adds nothing about which form to choose, 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 states a specific verb and resource: 'Add a property to Search Console.' 'Property' distinguishes it from the sitemap-oriented siblings such as wsp_add_sitemap_gsc, 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?

It gives a real prerequisite ('Requires WSP_ALLOW_WRITES=true'), which tells the agent when the call will succeed, but it offers no guidance on when to use this versus related operations like wsp_list_websites_gsc or wsp_show_website_gsc, and no note about when not to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so the safety and external-dependency profile is covered structurally. The description adds that results reflect "as Google sees it," hinting at live Google-side data rather than a cached local copy, but omits any mention of latency, quota/rate limits, or what happens when the URL is not in the property.

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 return facets listed compactly; no filler and nothing 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?

For a 2-parameter tool with no output schema, listing the returned facets (index status, last crawl, canonical, robots, rich results) usefully substitutes for a return-value spec. The only real gap is routing between this tool and the plural batch sibling, which sibling differentiation should have handled.

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 site_url property already explains the GSC property format, domain-property behavior and subdomain filtering. The description adds no parameter-level meaning beyond that, 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+resource ("Check a URL") and enumerates the exact facets returned: index status, last crawl, canonical, robots, rich results. Very clear what it does, but it never distinguishes itself from the near-identically named sibling wsp_check_urls_gsc, which invites mis-selection.

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 through the singular "a URL" – an agent can infer this is the single-URL inspector versus the batch sibling, but the description never says so or states prerequisites. It also doesn't say whether the URL must already be known/verified in 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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuine behavior beyond that: calls run concurrently and the response is one row per URL. It omits quota/rate-limit behavior, which matters for a batched inspection API and is the main operational risk an agent would want flagged.

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 capability and the cap, followed by the sibling equivalence. There is no filler and every clause carries information an agent needs to route the call correctly.

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-only tool with full schema coverage and rich annotations, the definition covers scope, limit, concurrency, and output shape (one row per URL) even without an output schema. The remaining gap is that the actual inspection fields returned are only implied by reference to the sibling 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%, including a detailed site_url explanation about domain properties covering subdomains, so the schema carries the semantics. The description only restates the "max 10" constraint already present in the urls schema description and adds no format or edge-case detail beyond it.

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 ("Inspect up to 10 URLs in one call") and explicitly distinguishes itself from the sibling wsp_check_url_gsc as the batch equivalent. It stops short of saying what data is actually inspected (the GSC index/inspection payload), so the agent must infer the payload from the name and the sibling reference.

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 names the alternative tool (wsp_check_url_gsc) and the condition that selects this one — multiple URLs, up to a hard cap of 10, run concurrently. There is no explicit when-not guidance (e.g. what to do with more than 10 URLs, or whether to prefer the single tool for one URL), which keeps it below a 5.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds genuinely non-structured behavior: the sign convention for deltas, the direction of position (lower is better), and that percentages are null when the Period 2 baseline is zero. It does not mention how many rows come back, ordering, or the 'top results' limiting behavior beyond what the schema's limit field says.

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

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

Front-loaded with the purpose, then a clearly separated 'Direction' block covering the interpretive rules. Every sentence carries decision-relevant information, and there is no restatement of the name or schema fields.

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 takes on the burden of explaining return semantics, and it does so: what deltas mean, the sign convention, and the zero-baseline null case. Combined with 100% schema coverage for inputs and annotations covering safety, an agent has enough to call and interpret this correctly.

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

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

Schema coverage is 100%, so the schema already documents each parameter, setting a baseline of 3. The description adds real meaning on top by defining the semantic role of each period (analyzed vs baseline) and how deltas are computed relative to them, which the schema's terse date descriptions do not convey.

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: 'Compare search performance across two date ranges.' This clearly separates it from sibling reporting tools like wsp_run_report_gsc and wsp_show_traffic_gsc, though it does not name those siblings explicitly. The purpose is unambiguous 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?

Gives concrete usage direction, notably 'For a current-vs-previous comparison, pass the current period as Period 1 and the previous period as Period 2,' which is exactly the kind of when/how guidance that prevents mis-ordered calls. It stops short of stating when to use this versus run_report or show_traffic, so no explicit exclusions or alternatives are offered.

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 a small signal about what is returned (queries tied to clicks and impressions) but omits meaningful behavioral context such as the default 28-day window being a lookback, GSC data freshness lag, or the 20-row default truncation.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity borders on under-specification rather than optimal density.

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

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

With no output schema, the description carries more burden to say what comes back, yet it only gestures at 'clicks and impressions' without indicating the other returned dimensions or the pagination/row-limit ceiling. The required site_url and page_url are fully documented in the schema, so the core invocation is still safe.

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 parameters are already well documented in structured data, including the site_url/domain-property nuance and row_limit tiers. The description contributes nothing 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 concrete resource and scope: search queries driving clicks and impressions for one specific page. An agent can distinguish it from site-wide siblings like wsp_show_traffic_gsc or wsp_run_report_gsc, though the description never names those alternatives 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 or when-not-to-use guidance in the description itself. The only routing hint (use wsp_run_report_gsc for exports beyond 500 rows) lives in the row_limit schema text, not the description, so the agent gets no explicit alternative-selection rule from the prose.

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 structurally. The description adds genuinely useful behavior the annotations do not: the output spans both domain and URL-prefix property types and yields the exact site_url string consumed by other tools. It omits any mention of permission requirements or behavior when the account has no properties, keeping it short of 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?

Two sentences, zero filler, with the scope (which property types) front-loaded and the downstream-purpose remark second. 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?

With no output schema, the description does its job by telling the agent what comes back (every accessible property plus the site_url strings). Given the sibling wsp_login_again_gsc exists, a note about what happens when the connection is unauthenticated would round it out, but nothing essential for correct 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?

The tool takes zero parameters, so there is nothing the description must disambiguate and the schema cannot be improved upon by prose. The baseline for a parameterless tool applies, with no evidence pulling it up or down.

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 ('List every Search Console property') and scopes it to 'domain and URL-prefix' types, which distinguishes it from siblings like wsp_show_website_gsc that operate on a single site. An agent can immediately tell this is the enumeration tool for the whole account.

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 sentence 'Returns the exact site_url string every other tool requires' gives clear contextual guidance: call this first to obtain the identifier that downstream tools need. It does not state exclusions or mention what to do on auth failure (e.g. wsp_login_again_gsc), so it falls short of a full when/when-not guide.

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 destructiveHint=true, openWorldHint=true, and non-readOnly, but the description adds the concrete consequence: the saved OAuth token is DELETED, and a browser is opened. That tells the agent what is destroyed and that the call is interactive, beyond what the hints convey. It stops short of covering failure modes (no browser available) or effects on in-flight sessions, which is why it is not a 5.

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

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

Two sentences, no filler: the first states the action, the second states the use cases. The destructive action is front-loaded before the rationale, which is the right ordering for an agent scanning for side effects.

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 parameters, no output schema, and annotations carrying the safety profile, the description covers what an agent needs: what happens, what is destroyed, and when to invoke it. The one remaining gap is that it does not warn that a browser/interactive environment is required or what happens if login fails.

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 no parameter meaning for the description to add. The baseline for a 0-param tool applies, and nothing here misleads about 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?

The description gives a specific verb and object pair: it deletes the saved OAuth token and opens a browser login. This is unmistakably distinct from every sibling, which are all Google Search Console data operations (sitemaps, sites, URLs, traffic), so an agent can route to it without opening a schema.

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

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

It explicitly names three triggering situations: switching Google accounts, fixing auth errors, and applying a changed WSP_ALLOW_WRITES setting. It does not state when NOT to use it or name an alternative (e.g. a read-only status check first), so it falls short of full when/when-not guidance.

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

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

The annotations already declare destructiveHint=true and idempotentHint=true, but the description adds context the annotations cannot carry: that already-indexed URLs remain indexed after unsubmission, and that the WSP_ALLOW_WRITES=true environment flag is a hard prerequisite. Those two facts materially change an agent's risk calculus and failure handling, though propagation delay or whether removal is reversible is unstated.

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

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

Three short sentences with zero filler: action first, side effect second, prerequisite third. Every sentence earns its place 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?

For a two-parameter destructive tool with full schema coverage and no output schema, the description covers action, residual effect, and the write-permission gate. A pointer to wsp_show_sitemaps_gsc for verification before removal would close the remaining gap.

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

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

Schema description coverage is 100%, so both site_url and sitemap_url are already documented in the schema, including the domain-property nuance. The description adds no parameter-level meaning beyond that, 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?

"Unsubmit a sitemap" gives a specific verb and resource, and the word choice implicitly contrasts with the sibling wsp_add_sitemap_gsc. It stops short of explicitly naming the counterpart tool, so an agent still has to infer the pairing 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?

The description implies the use case (removing a sitemap submission from GSC) but gives no explicit when-to-use or when-not-to-use guidance, and does not point at wsp_show_sitemaps_gsc to first confirm the sitemap exists. Usage is inferable rather than 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?

The annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is largely covered. The description's one contribution is the write-gate requirement, WSP_ALLOW_WRITES=true, which is real context not present in the structured fields. It does not explain what removal actually entails (losing verification, effect on sitemaps, whether it is reversible).

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 action front-loaded and no filler. The prerequisite is appended efficiently, though it is cryptic as written, giving no hint about how or where WSP_ALLOW_WRITES is set.

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-parameter, single-purpose destructive tool with a fully documented schema and explicit destructive/idempotent annotations, the description plus structured data covers what an agent needs to invoke it. The remaining gap, consequences of removal, is modest given the destructiveHint annotation.

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

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

There is a single required parameter with 100% schema description coverage, including the exact-match URL and sc-domain: formats. The description adds no meaning beyond that schema text, which is the baseline case for high coverage.

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

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

States a specific verb and resource: 'Remove a property from Search Console.' An agent can tell this apart from wsp_add_website_gsc and wsp_show_website_gsc by the verb alone. It stops short of naming the sibling it contrasts with, but the action is unambiguous.

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 verb (call this to delete a property) plus a gating prerequisite, 'Requires WSP_ALLOW_WRITES=true.' There is no explicit statement of when to prefer this over wsp_add_website_gsc or how to recover from a mistaken removal.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered externally. The description adds one genuinely useful behavioral fact: the 25,000-row ceiling. It says nothing about API quota consumption, latency, or that sorting beyond clicks is applied client-side (that detail lives only in the schema), so it adds modest 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?

A single sentence that front-loads the capability and then enumerates the knobs, with the row cap as a trailing parenthetical. Nothing is wasted and it is easy to scan. It is slightly list-like and could have spent those words on routing guidance instead, which keeps it from a 5.

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

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

For a 14-parameter analytics query tool with no output schema, the description covers what the tool does but not what comes back (row shape, metric columns) or which sibling to use for prebuilt views. The rich schema compensates for parameter-level gaps, leaving the description adequate but not complete for the tool's complexity.

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

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

Schema description coverage is 100%, so every one of the 14 parameters is already documented in the schema, including defaults, filter JSON structure and the client-side sorting caveat. The description only restates the parameter categories in prose ('dimensions, date range, search type, filters, sorting and pagination'). Baseline 3 is appropriate when the schema carries the semantics.

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

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

The description states a concrete capability: running a search-analytics report with configurable dimensions, dates, search type, filters, sorting and pagination. An agent can tell this is the general-purpose query tool of the GSC family. It stops short of explicitly differentiating itself from siblings like wsp_show_traffic_gsc or wsp_compare_dates_gsc, so 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?

There is no when-to-use guidance and no named alternatives, despite the sibling set containing overlapping reporting tools (wsp_show_traffic_gsc, wsp_compare_dates_gsc, wsp_find_page_keywords_gsc). The word 'Flexible' only implies this is the general fallback. Nothing tells the agent when to pick this tool over a prebuilt report.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds that the response includes full status and a per-content-type breakdown, which is meaningful given there is no output schema, but it says nothing about what happens when the sitemap is not registered or not yet processed.

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; every clause (status, per-content-type breakdown, one sitemap) 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?

For a two-parameter read-only tool with a fully documented schema, this is close to adequate, and the hint about the per-content-type breakdown partially compensates for the missing output schema. What is missing is how it relates to the list/add/remove sitemap siblings and any error or empty-state behavior.

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

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

Schema description coverage is 100% and the schema already explains that site_url must be the exact GSC property URL from wsp_list_websites_gsc, including the domain-property nuance. The description adds no parameter 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?

"Full status and per-content-type breakdown for one sitemap" names the resource (a single sitemap) and the kind of data returned (status plus per-content-type breakdown). The phrase "for one sitemap" implicitly separates it from the plural listing sibling wsp_show_sitemaps_gsc, but that sibling is never named, so differentiation relies on the agent noticing the singular/plural contrast.

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

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

The description gives no when-to-use guidance, no prerequisite ordering (e.g. list sitemaps first via wsp_show_sitemaps_gsc), and no exclusions relative to wsp_show_status_gsc or wsp_show_website_gsc. Usage is only inferable from the word "one".

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds value the annotations cannot: it discloses the shape of the payload an agent will get back (status, URL counts, errors, warnings), which matters because no output schema exists. It does not mention pagination or auth/scope requirements.

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 filler, with the core behavior front-loaded and the optional parameter path immediately after. Nothing is repeated 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?

For a two-parameter read-only listing tool with no output schema, the description covers purpose, the optional index-expansion mode, and the returned fields. The only remaining gap is that the site_url property's domain-property nuance lives solely in the schema rather than the description, which is a minor omission.

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 in the schema, including sitemap_index as "Optional sitemap index URL to list child sitemaps." The description's mention of sitemap_index largely restates the schema, and site_url is not addressed at all, so the baseline 3 applies.

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

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

States a specific verb and resource ("List submitted sitemaps") and enumerates what is returned (status, URL counts, errors, warnings), which separates it from the singular wsp_show_sitemap_gsc and the mutation siblings wsp_add_sitemap_gsc/wsp_remove_sitemap_gsc. It stops short of naming an alternative explicitly, so 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 second sentence gives real guidance for one path: pass sitemap_index to enumerate an index's children. There is no statement of when to prefer this over wsp_show_sitemap_gsc or when not to use it, so usage is only partially implied.

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, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds value beyond them by disclosing what the call returns (the tool inventory grouped by category plus authentication status), which is essential since no output schema exists. It does not mention that no arguments are taken, but that is visible in the 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?

Two sentences, no filler: the first defines the operation and its output, the second gives the call-ordering advice. The most actionable instruction ("Call it first") is placed where it will be read.

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-argument, read-only discovery tool with no output schema, an agent needs to know what comes back and when to reach for it — both are stated. There are no parameters, no mutation risk, and no return format left implicit that would change how the tool is invoked.

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 the description needs to disambiguate beyond what the empty schema already conveys. The baseline for a parameterless tool is a 4, and nothing here lowers it.

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?

"List every tool this server offers, grouped by category, with the current authentication status" gives a concrete verb (list) and a precise resource (the server's tool inventory + auth state). This is unmistakably the meta/discovery tool among siblings like wsp_list_websites_gsc or wsp_show_sitemaps_gsc, which return Search Console data rather than tool metadata.

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?

"Call it first to learn what is available or to diagnose login problems" states both a call ordering and two triggering conditions, which is strong guidance for a discovery tool. It stops short of naming the natural alternative for auth repair (wsp_login_again_gsc), so an agent must infer which of the two to use when a login is actually broken.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds value beyond that by disclosing the return shape and the lookback-window behavior (last N days), which is not visible in the annotations. It omits data-freshness lag, sampling/row limits, and what happens when there is no traffic, so it is not fully transparent.

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 puts the returned metrics first and the time scope second, with no filler. It is a sentence fragment without a verb, which is efficient but slightly less scannable than a complete 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?

For a two-parameter read-only tool with full schema coverage, the description covers both what it returns and its temporal scope, doing the work an output schema would otherwise do. Missing only edge-case behavior (empty results, data delay) and routing guidance against four other GSC query siblings.

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, and the schema even explains the domain-property nuance for site_url. The description adds only the 'last N days' framing, which the days parameter description already conveys, so baseline 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?

It names the concrete return payload (clicks, impressions, CTR, position) plus a daily trend over the last N days, so an agent knows exactly what it gets. It stops short of naming the resource as Search Console traffic or distinguishing itself from siblings like wsp_compare_dates_gsc or wsp_run_report_gsc.

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 summary-plus-trend framing suggests a quick overview rather than a detailed report, which weakly separates it from the report/comparison siblings. There is no explicit when-to-use, when-not-to-use, or named alternative, and no prerequisite (e.g. needing a site_url from wsp_list_websites_gsc) is 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 safety is covered. The description adds value by disclosing what the read returns (permission level, verification and ownership state), which matters since there is no output schema; it does not state error behavior for inaccessible or unverified 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?

A single front-loaded sentence fragment with zero filler, and the returned-fields list comes first. It is efficient but slightly terse, reading more like a field inventory than a full definition.

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-parameter, read-only lookup with full schema coverage and no output schema, the description covers the essential question of what data comes back. Remaining gaps (failure modes, prerequisites) are minor for a tool this simple.

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 site_url field already explains exact-URL format, domain-property semantics, and subdomain filtering. The description adds nothing beyond 'one property', 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 the resource ('one property') and enumerates the returned data: permission level, verification, and ownership details. That distinguishes it from the list-oriented sibling wsp_list_websites_gsc by emphasizing single-property scope, though the verb is only implied by the title.

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 'for one property', which suggests calling this after discovering a property URL, but no alternative is named and no when-not condition is given. An agent must infer that wsp_list_websites_gsc is the prerequisite discovery step, even though the schema hint mentions it.

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