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

Annotations already declare non-readonly, idempotent, non-destructive, and open-world behavior, so the bar is lower. The description adds a genuinely valuable non-obvious trait: 'Adding a property does not verify it,' plus the ownership-proof workflow, which no annotation conveys. It stops short of describing return values or error conditions.

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 purpose, then trigger, then the crucial non-verification caveat, then the follow-up workflow. Four sentences, each carrying distinct information with no redundancy.

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 single-parameter mutation tool with no output schema, the description supplies what matters most: the non-verification caveat and the verification follow-up chain. An agent has everything needed to invoke it correctly and guide the user'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?

Schema coverage is 100% with a single parameter whose description already specifies the exact URL formats (e.g., "https://example.com/" or "sc-domain:example.com"). The description only loosely restates 'a site URL or a domain,' adding no format detail beyond the schema, 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 ('Register') and resource ('a site URL or a domain as a Google Search Console property'), naming the target system and account scope. This clearly distinguishes it from siblings like delete_property, list_properties, and gsc_verify_site.

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?

Explicitly states the trigger ('Use when the user asks to add a site to Search Console') and routes to the correct follow-up tools (gsc_get_verification_token, gsc_verify_site) and the alternative for viewing existing sites (list_properties). Both when-to-use and what-to-use-instead are covered.

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, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds that this returns classified aggregates rather than a ranked list, which is useful output-shape context, but it says nothing about data freshness, result size limits, or what happens with sparse data. Adequate but not rich beyond the annotations.

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

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

Three sentences, each earning its place: purpose first, usage condition second, sibling routing third. No filler or restated name/title content.

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

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

There is no output schema, and the description partially compensates by describing the classification axes the result is bucketed into (intent, branded demand, position band). It still leaves the exact returned fields/shape unspecified, which matters for an aggregation tool, but the safety profile is fully covered by 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%, with period and searchType enums and minImpressions bounds fully documented in the schema. The description mentions no parameter syntax or defaults, so it adds nothing beyond the structured fields; 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 ("Classify") and resource ("Search Console queries of a property") and names the three classification axes (intent, branded vs non-branded, position band). This clearly separates it from sibling listing tools like get_top_queries, which the description explicitly contrasts against ("a list of winners").

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 an explicit when-to-use condition ("shape of search demand rather than a list of winners") and routes to two named alternatives with their selecting conditions: find_new_queries for newly appearing queries and find_cannibalization for shared queries across pages. Nothing 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 real behavioral value by disclosing the response shape (indexed / not indexed / errors) and what fields each group carries, though it says nothing about GSC rate limits or quota behavior for a 50-URL batch.

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

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

Three sentences, front-loaded with the core capability, then output semantics, then routing guidance. Every sentence earns its place, though the middle sentence is dense with enumerated fields and could be tighter.

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 the return-value burden and does so by describing the three result groups and their fields. Only minor gaps remain, such as batch failure/partial-error handling and API quota considerations.

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 both parameters are already documented in the schema, including the GSC-specific siteUrl format. The description restates the 50-URL cap and the list input but adds no syntax or format detail beyond the schema, 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?

The description states a specific verb ('inspect'), resource ('URLs'), and scope ('up to 50 in one call'), then defines the three output groupings. It is immediately distinguishable from the single-URL sibling 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?

It gives an explicit trigger ('when the user hands over a list of URLs') and names both alternatives with their selecting conditions: inspect_url for a single URL and check_indexing_issues for top traffic pages when no list is supplied.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds real value beyond that by disclosing the audit's scope - the specific check categories it performs - though it says nothing about limits, batching, or what the report contains.

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

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

Three sentences, all load-bearing: the first defines the audit scope, the second defines the trigger condition, the third routes away to the sibling. The scope is front-loaded and there is no filler.

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

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

For a read-only audit tool with annotations covering safety and a 100%-documented two-parameter schema, the description supplies what the agent needs to pick and invoke it. The remaining gap is that no output schema exists and the return/report shape is never described, so the agent cannot anticipate what the audit yields.

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 (exact GSC format) and limit (default 20, max 100) are already fully documented in the schema. The description adds no parameter-level meaning beyond the schema, 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 (Audit) plus the exact resource (top traffic pages of a property) and enumerates the four failure classes it detects: indexing failures, canonical mismatches, missing canonicals, and mobile problems. It is immediately distinguishable from the inspect_url/batch_inspect_urls siblings.

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

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

Gives an explicit when-to-use condition (an indexing health pass on traffic pages) and an explicit exclusion with a named alternative set (use inspect_url or batch_inspect_urls when the URL list already exists). Nothing about routing 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 readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety and idempotency profile is fully covered. The description adds little behavioral context beyond this — it does not describe the returned comparison shape (deltas, ordering) or any rate/quota behavior. With annotations carrying the safety burden, a 3 is appropriate.

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

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

Three sentences, each earning its place: capability, when-to-use, and the routing alternative. Front-loaded with the primary action and no filler.

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

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

No output schema exists, but the description names the compared metrics and grouping option, and annotations cover the safety profile. It is nearly complete for a read-only comparison tool; only the shape of the returned comparison is unspecified, a minor 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 every parameter including the four date fields and the dimensions enum is already documented in the schema. The description's 'optionally grouped by a dimension' merely restates a schema-declared option without adding syntax or meaning. Baseline 3 is correct 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?

States a specific verb (compare) plus the exact resource (Search Console clicks, impressions, CTR, position) over two explicit date ranges, and names the sibling it is not (get_performance_summary). An agent can distinguish it from the other analytics tools 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?

Explicitly says when to use it ('when the user names a before and an after, such as a release or a season') and names the alternative with its own selecting condition ('latest period against the one just before it, without choosing dates'). Nothing 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 destructiveHint=true and idempotentHint=true, but the description goes further and clarifies the blast radius: the property can be re-added later and historical data held by Google is NOT erased. That is exactly the kind of scope-of-destruction context the annotations alone cannot convey.

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

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

Four short sentences, front-loaded with the operation and then the routing guidance. 'The property can be added back later' and 'call add_property to register the site again' overlap slightly on reversibility, but each otherwise 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 single-parameter destructive mutation with full annotation coverage, the description covers purpose, trigger, reversibility, data-retention scope, and alternatives — everything an agent needs to call it correctly and route around it when appropriate.

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% for the single siteUrl parameter, including the sc-domain: format example, so the schema already carries the semantics. The description adds no format guidance beyond what the schema provides — the correct baseline 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?

States a specific verb (remove) and resource (Google Search Console property from the authenticated account site list), which distinguishes it cleanly from sibling mutations like delete_sitemap and add_property. An agent can identify the operation 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 an explicit trigger condition ('when the user explicitly asks to drop a property') and names two alternatives with their selection conditions: delete_sitemap for withdrawing a sitemap and add_property for re-registering the site. Nothing 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 destructiveHint=true and idempotentHint=true, so the mutation profile is covered. The description adds genuinely non-obvious context beyond the annotations: 'Removing the sitemap does not drop its URLs from the Google index,' which corrects a likely misconception. It stops short of permissions/auth detail, so 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?

Three sentences, front-loaded with the action, followed by the usage condition, the key caveat, and sibling routing. No filler.

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

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

For a two-parameter destructive tool with no output schema, the description covers effect, the index-persistence caveat, and sibling routing. An agent has everything needed to call it 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% and both parameters (siteUrl, feedpath) are fully documented in the schema. The description adds no format or syntax guidance beyond what the schema already provides, 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: 'Withdraw a previously submitted sitemap from a Google Search Console property.' This clearly distinguishes it from submit_sitemap and list_sitemaps without opening their schemas.

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?

Explicitly names the trigger ('when the user asks to remove a stale, duplicated, or broken sitemap') and routes to the correct alternatives: submit_sitemap to re-file and list_sitemaps to review what remains. Both when-to-use and sibling disambiguation are present.

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 output semantics beyond that: the report identifies the page that wins the clicks, implying a comparative winner-per-query result rather than a raw list. It does not discuss pagination or result size limits, but that is a minor gap given annotation coverage.

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

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

Three sentences, each earning its place: the first defines the operation and result, the second gives the trigger condition, the third dispatches to two siblings. Front-loaded with the core action and zero filler.

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

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

There is no output schema, so the description must convey the return shape; it does so at a functional level ('name the page that wins the clicks'). It does not detail the full result structure or how many cannibalizing queries are returned, which is a modest gap for a read-only analysis 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 detailed semantics for siteUrl and the minPageImpressions low-volume rule, so the schema carries the parameter burden. The description adds nothing about parameter meaning, making the baseline 3 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?

States a specific verb and resource: detects query cannibalization where multiple pages of a property rank for the same query, and reports which page wins clicks. This is clearly distinguishable from siblings like get_top_pages or find_content_gaps without opening any schema.

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

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

Explicitly names the triggering user question ('whether their own pages compete for the same query') and routes to two specific alternatives with their own conditions: find_content_gaps for wrong-page landings and get_top_pages for a plain ranking. Nothing 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 what gaps are surfaced but says nothing about scoping limits, ordering, result volume, or how period/siteUrl constraints affect findings. Adequate but not rich behavioral context.

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

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

Three tight sentences: what it finds, when to use it, and which siblings cover adjacent jobs. No filler and the core capability 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 no output schema, the description carries the return-value burden, and enumerating the three gap types gives the agent a reasonable expectation of results. Minor gap: it doesn't note that findings are derived from Search Console data over the selected period, which would help set expectations.

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

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

Schema description coverage is 100% with enum values and defaults already documented, so the baseline is 3. The description adds no syntax or interpretation guidance beyond the schema; minImpressions semantics such as what counts as 'high impression' are not clarified.

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 (Find) and resource (content gaps), then enumerates the three concrete gap categories it detects: misrouted queries, high-impression zero-click queries, and uncovered topics. This is clearly distinguishable from siblings like find_cannibalization or find_what_to_build_next.

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 an explicit trigger ('Use when the user asks what content is missing') and routes to two named alternatives with their own conditions: find_what_to_build_next for intent grouping and find_cannibalization when pages compete for one query. When-to-use and when-to-use-something-else are both covered.

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 and the bar is lower. The description still adds real behavioral value by disclosing the selection logic (CTR relative to position benchmark, not absolute CTR) and that each result carries an attached fix note, which the agent cannot infer from structured fields.

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

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

Three sentences, zero filler, front-loaded with the selection criterion before the routing guidance. 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 read-only analytical tool whose annotations cover safety, the description plus full schema coverage is nearly sufficient; the mention of the per-page fix note partly compensates for the absent output schema. It does not sketch the returned fields (impressions, clicks, CTR, position), which would have closed 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% with enum values for period and searchType, so the schema fully carries parameter meaning. The description adds no format, default, or interaction detail (e.g. how minImpressions affects recall), 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 (Find) plus the exact resource and selection criterion: pages whose CTR sits below the benchmark for their average position. It also names the distinctive output (a fix note per page), which differentiates it from the plain-ranking and query-level siblings.

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

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

Gives an explicit trigger ('when the user asks which titles or snippets are wasting impressions') and then routes the agent away to two named alternatives with the conditions that select them (find_quick_wins for near-page-one query/page pairs, get_top_pages for a plain traffic ranking). Nothing 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the comparison semantics (current vs previous period), but says nothing about how the minClicksInPrevious threshold affects results or how ties/limited rows are handled. With annotations doing heavy lifting, a 3 is appropriate.

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, each earning its place: purpose, trigger, then disambiguation. The core action is front-loaded before the sibling routing.

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

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

No output schema exists, but the description conveys the shape of the result (ranked pages and queries that lost clicks) and the comparison basis. Fully covered parameters and annotations mean the only real gap is threshold/limit behavior, which is minor.

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

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

Schema description coverage is 100% and both enums (period, searchType) are documented in-schema, so the baseline is 3. The description adds no parameter-level syntax, defaults, or interaction detail beyond what the schema already states.

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

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

States a specific verb (compare) plus resource (current vs previous Search Console period) and the exact ranking output (pages and queries that lost clicks). This distinguishes it from siblings like get_top_queries or compare_periods, which don't frame the result as a decline ranking.

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 an explicit trigger ("Use when the user asks what stopped getting traffic or what dropped recently") and routes two alternatives by condition: find_quick_wins for under-clicked but not declining, weekly_seo_report for a full digest. Nothing 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely useful behavioral context by disclosing that results come from a period-over-period diff, which explains why the period parameter matters and why output is comparative. It does not mention rate limits, pagination, or result size.

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 purpose and comparison mechanism front-loaded before the routing guidance. 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?

Covers purpose, trigger, and sibling routing for a 4-parameter read tool whose annotations handle safety and whose schema documents all parameters. The one gap is that no output schema exists, so a brief note on what the result set contains (e.g. query strings with change metrics) would have closed the loop.

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

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

Schema description coverage is 100% with enums for period and searchType and a documented siteUrl format, so the schema already does the heavy lifting. The description only indirectly touches parameters by referencing the current-vs-previous period diff; it adds no syntax or threshold guidance (e.g. what minImpressions does to results). 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?

States a specific verb and resource (find queries that are new or rising) plus the mechanism (diffing this period against the previous one). This lets an agent distinguish it from get_top_queries or compare_periods without opening any schema.

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

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

Gives an explicit trigger ("Use when the user asks what people started searching recently") and routes to two named alternatives with the conditions that select them: analyze_query_landscape for overall intent mix, find_what_to_build_next for topic grouping. Nothing 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 readOnlyHint, idempotentHint, and non-destructive, so the safety profile is covered. The description adds genuine behavioral context by defining the heuristics that make something a 'quick win,' which is not derivable from the annotations. It stops short of describing return shape or pagination, but the annotation coverage lowers the bar.

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

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

Three tight sentences with zero waste, front-loaded on the core purpose, then the usage trigger, then the sibling routing. Every sentence earns its place and the structure leads with what the tool does.

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

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

For a read-only analysis tool with strong annotations and full parameter documentation, the description is nearly complete. With no output schema, it could hint at return shape, but the criteria for qualification and the sibling routing give the agent enough to call it 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 description coverage is 100% and each of the four parameters (period, siteUrl, searchType, minImpressions) is documented in the schema, including enum values. The description adds no syntax or format detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

States a specific verb ('Find') and resource ('query and page pairs') and defines the three criteria that qualify (rank well but under-clicked, just off page one, small position push). It explicitly distinguishes itself from find_ctr_opportunities and find_declining_content, so an agent can tell it apart from siblings 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?

Gives an explicit trigger ('Use when the user asks where search traffic is being left on the table') plus named alternatives with their selecting conditions: find_ctr_opportunities for page-level CTR gaps and find_declining_content for already-falling traffic. When-to-use and when-to-use-something-else are both covered.

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, openWorldHint and destructiveHint=false, so safety is covered. The description adds the grouping/clustering behavior and the intent taxonomy, but says nothing about output shape, result volume, or site/auth prerequisites. With annotations carrying the safety profile, this is adequate but not rich.

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

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

Three tightly packed sentences: purpose first, then usage trigger, then alternatives. Every clause earns its place with no repetition or filler.

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

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

For a read-only analysis tool with four well-documented params, the description gives enough to select and invoke it correctly. The only gap is the absence of any hint about the returned cluster structure, which matters slightly more since no output schema exists.

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 period, siteUrl, searchType and minImpressions are already fully documented with types, defaults, enums and examples. The description adds no parameter-level semantics, which is the correct baseline 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?

States a specific verb and resource ('Group Search Console queries by user intent... into topic clusters') with the intent categories enumerated. This is clearly distinguishable from siblings like find_content_gaps and analyze_query_landscape.

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?

Explicitly states when to use ('Use when the user asks what content to create') and routes the agent to two named alternatives with the conditions that select them ('mismatched landing pages and zero-click queries' -> find_content_gaps; 'overall intent mix' -> analyze_query_landscape).

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

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

Annotations already declare readOnlyHint=false and idempotentHint=false, so the agent knows this is a mutating, non-idempotent write. The description adds genuinely new context beyond that: the server cannot delete the stream afterwards, so creation is effectively irreversible. This is valuable since destructiveHint=false might otherwise imply easy reversibility.

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 action and return value, then usage condition, caveat, and alternatives in a logical order. Three sentences, each earning its place, though slightly dense.

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 create tool with annotations covering the safety profile, the description names the return value (measurement id), the irreversibility caveat, and prerequisite/alternative tools. No output schema exists, but the description states what is returned, so the agent has enough to call it 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 description coverage is 100%, so the schema already documents url, property_id, and stream_name with examples. The description adds no syntax or format detail beyond what the schema provides. 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?

States a specific verb+resource ('Create a web data stream on a Google Analytics 4 property') and even names the return value ('return its measurement id'). This clearly distinguishes it from siblings like ga4_list_data_streams and ga4_create_property.

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

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

Explicitly states when to use it ('when the user needs a measurement id to install analytics on a site') and routes to alternatives with conditions: call ga4_list_data_streams if a stream may already exist, and ga4_create_property first when the property does not exist. Nothing 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 cover the mutation profile (readOnly=false, destructive=false, idempotent=false, openWorld=true). The description adds genuinely new behavioral context: the property cannot be removed afterwards by this server, which is an irreversibility warning not captured by destructiveHint=false, plus sequencing to the data stream step.

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

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

Four short sentences, front-loaded with the core action and followed by usage, irreversibility, and next steps. Each sentence carries information; minor tightening is possible but nothing is wasted.

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

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

For a creation tool with annotations and no output schema, the description covers trigger, parent scoping, irreversibility, and follow-up calls. It stops short of noting what the newly created property returns (e.g., property ID), which would help since no output schema exists.

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

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

Schema description coverage is 100%, so all five parameters including account_id and industry_category are documented in the schema. The description names three of the fields but adds no format or constraint detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource (create a GA4 property), names the parent resource (account), and lists the key fields (display name, timezone, currency). An agent can distinguish this from ga4_list_properties and ga4_get_property immediately.

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?

"Use when the user asks to provision a GA4 property" gives a clear trigger, and it explicitly routes to ga4_list_properties first and ga4_create_data_stream next. No explicit when-not condition (e.g., vs add_property) is given, so it falls short of 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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds real value by disclosing the returned content (measurement id, default URI, timestamps), though it says nothing about auth requirements, rate limits, or errors.

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 compact sentences with the core action front-loaded, followed by usage condition and the sibling routing. Every sentence earns its place with no redundancy.

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

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

For a simple two-parameter read with no output schema, the description compensates by enumerating the returned fields and pointing to the list tool for id discovery. Combined with annotations carrying the safety profile, nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100%, so both property_id and stream_id are already documented with format examples ("789012", "properties/123456"). The description references the stream id but adds no formatting or semantics beyond the schema, 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 ("Read") and resource ("one Google Analytics 4 data stream") and enumerates what is returned (measurement id, default URI, created and updated times). It also distinguishes itself from the sibling ga4_list_data_streams by naming it, so an agent can pick it 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?

"Use when the user names a stream and wants its measurement id or settings" gives an explicit trigger, and "Call ga4_list_data_streams when the stream id is not known yet" names the alternative plus the condition that selects it. Nothing 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 readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so safety is covered. The description still adds value by clarifying the return shape is names only ('this tool does not return the numbers') and that custom definitions are included. It stops short of describing pagination or response volume, so a 4 rather than 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?

Three tight sentences with no filler: the first defines the output, the second states the trigger, the third routes to the sibling and rules out a false expectation. The most important 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?

For a single-parameter read-only metadata tool with no output schema, the description tells the agent what it gets (names plus custom definitions), what it does not get (numbers), and the workflow it feeds into. Nothing needed to invoke it correctly 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?

Only one parameter, and schema description coverage is 100%, so the schema fully documents property_id (with both ID formats). The description adds nothing about the parameter, 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 the dimensions and metrics a Google Analytics 4 property accepts.' It also delimits scope ('including custom definitions') and explicitly distinguishes itself from the reporting sibling by noting it does not return numbers.

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 an explicit trigger ('when a report needs valid metric and dimension names and guessing would be wrong') and names the follow-up tool and sequence ('Call ga4_run_report once the names are known'). The alternative tool is named and the ordering is unambiguous.

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 genuinely new behavioral context: the id must be sourced from another call first, and it enumerates what the read returns in the absence of an output schema. It stops short of noting auth/scope requirements or staleness of the returned values.

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 operation and its return fields, followed by the routing/prerequisite advice. Every clause carries information and no filler is present.

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 single-parameter read with no output schema, the description is complete: it enumerates the returned fields, defines the use case, and points to the sibling calls needed before and after. An agent can select and invoke this tool correctly from the description alone.

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

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

Schema coverage is 100% and the single property_id parameter is already documented with accepted formats ("123456" or "properties/123456"). The description adds no further syntax, defaults, or format guidance beyond what the schema provides, so the baseline 3 applies.

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

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

The description names a specific verb (read) and resource (one GA4 property) and enumerates the exact configuration fields returned (display name, timezone, currency, industry, parent account). This cleanly distinguishes it from ga4_list_properties (plural listing) and ga4_get_data_stream (different resource) without opening any schema.

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

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

It states exactly when to use it ("when the user asks how a known property is configured") and supplies both a prerequisite (call ga4_list_properties to obtain the id) and a routing rule (use ga4_list_data_streams for streams). Nothing 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 readOnlyHint, idempotentHint, and openWorldHint, so the safety and idempotency profile is covered. The description usefully adds that the listing is scoped to what the credentials can reach and that properties are nested under accounts, but says nothing about return shape or pagination behavior for a potentially large enumeration.

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, each earning its place: the what, the when-to-use, and the sibling routing. Front-loaded with the primary action and no filler.

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

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

With no output schema and no parameters, the description carries the burden of conveying what comes back, and it does state accounts plus their properties. It is complete enough to invoke correctly, though it stops short of describing nested result structure or volume limits for a discovery call.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; no input semantics are needed. Baseline for a parameterless tool applies, with no gap introduced by the description.

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

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

States a specific verb ('List') and resource ('every Google Analytics 4 account'), plus the scope of the result (accounts and the properties under each). This is clearly distinguishable from sibling tools like ga4_list_properties or ga4_get_property.

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

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

Explicitly states the triggering condition ('Use when the user does not yet know the account or property id') and names two alternatives with the conditions that select them (ga4_list_properties when an account is already named, ga4_get_property for one property's settings). Nothing 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 readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some return content context ('including each web stream measurement id and default URI'), but does not disclose auth needs, rate limits, pagination, or other behavioral traits beyond what the annotations and schema already provide.

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 waste: purpose first, then usage context, then explicit alternatives. Information is front-loaded and 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 read-only list tool with one required parameter, covered annotations, and no output schema, the description gives everything an agent needs to select and call it correctly: purpose, trigger condition, return content note, and sibling routing.

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 one parameter with 100% schema description coverage, and the schema already documents property_id format and examples. The description does not add parameter-level syntax or meaning beyond what the schema provides, so the 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?

States a specific verb (List) and resource (data streams on a GA4 property), and identifies the sibling tools (ga4_get_data_stream, ga4_create_data_stream) it should not be confused with. An agent can distinguish this list operation from single-stream retrieval and creation without opening any schema.

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

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

Explicitly says when to use it ('when the user asks which streams or measurement ids a property already has') and names both alternative tools with their distinct conditions ('Call ga4_get_data_stream for one stream, and call ga4_create_data_stream only when they want a new stream'). This is complete routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered structurally. The description adds only the fact that results are scoped to a single account and enumerates returned fields; it says nothing about pagination, result caps, or empty-account 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?

Three tight sentences, front-loaded with the action and return content, then the usage condition, then the sibling routing. Every sentence earns its place with no redundancy.

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

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

No output schema exists, so the description carries the burden of describing returns, and it does name timezone, currency, and creation time. It stops short of describing the list shape (array, ordering, pagination), which is a minor gap for a simple one-parameter read 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 only one parameter exists, so the schema fully documents account_id including its accepted formats. The description's mention of 'one account' implies the parameter but adds no syntax or format detail beyond the schema, making the baseline 3 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?

States a specific verb and resource ('List Google Analytics 4 properties') plus the scoping constraint ('under one account') and the fields returned. It is clearly separable from ga4_get_property and ga4_list_accounts, which it names 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?

Gives an explicit when-to-use condition ('when the user names an account and wants its properties') and routes to alternatives with their own conditions: ga4_list_accounts when the account id is unknown, ga4_get_property to open one property. Nothing 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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds the meaningful 30-minute live window constraint and an error-recovery path via ga4_get_metadata, but says nothing about quotas, sampling, or how results are shaped.

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 compact sentences with zero filler: what it does, when to use it, and where to go instead. The purpose and the live-window scope are front-loaded before the routing advice.

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

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

For a three-parameter read-only report tool with full schema coverage and no output schema, the description covers scope, trigger, and fallbacks adequately. Return shape and pagination are not addressed, though the caller has no output schema to rely on.

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

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

Schema description coverage is 100% with examples for metrics, dimensions, and property_id, so the schema carries parameter meaning. The description adds no syntax or constraint detail beyond what the schema already documents, making the baseline 3 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 (Run), resource (GA4 realtime report), and scope (active users and on-site activity from the last thirty minutes). It is clearly distinguishable from the sibling ga4_run_report, which it names 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?

Gives an explicit trigger condition ("Use when the user asks who is on the site right now") plus two routing rules: ga4_run_report for older date ranges and ga4_get_metadata for rejected realtime metric names. When-to-use, when-not, and alternatives are all covered.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that it's for historical data and suggests a prerequisite step, but doesn't describe pagination, rate limits, or error behavior. With annotations handling the core safety, a 3 is appropriate.

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

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

Three sentences, each earning its place: one defines the action, one specifies the use case, and one routes to alternatives. No redundant or vague phrasing; front-loaded with the primary 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?

For a read-only report tool with full parameter documentation and no output schema, the description covers what the tool does, when to use it, and key prerequisites. It could mention output format or pagination, but is largely sufficient for correct invocation.

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

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

Schema coverage is 100%, so all parameters are already documented with examples and constraints. The description mentions the types of inputs (metrics, dimensions, date range) but adds no syntax or format details beyond what the schema provides. Baseline 3 is correct 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?

Explicitly states the verb (Run) and resource (Google Analytics 4 report) along with scope (metrics, dimensions, date range). It distinguishes itself from sibling ga4_run_realtime_report by contrasting historical numbers with 'who is on the site right now'.

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?

Provides clear when-to-use guidance: for historical GA4 numbers such as users, sessions, or page views. It names the alternative tool (ga4_run_realtime_report) for the opposite case and recommends calling ga4_get_metadata before guessing custom metric names.

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 bar is lower. The description adds genuine behavioral context beyond them: the result is scoped to a single property and benchmarked against the previous period of equal length, which shapes how results should be interpreted. It omits auth/rate-limit details and return format, but that is a minor gap given the annotation coverage.

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

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

Three tight sentences: purpose first, then usage condition, then sibling alternatives. No redundancy and 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 read-only summary tool with no output schema and annotations carrying the safety profile, the description is largely complete: it conveys scope, comparison semantics, and routing. Return shape is not described, but with no output schema the agent could not get that from structured fields anyway.

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, period, and searchType are fully documented in the schema with enums and defaults. The description reinforces 'one property' and 'named period' but adds no syntax or format detail beyond the schema, making the baseline 3 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 (summarize) and resource (clicks, impressions, CTR, average position for one property), plus the distinguishing scope of comparing against the prior period. It explicitly names the siblings it is not (compare_periods, get_search_analytics), so an agent can differentiate 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?

Gives an explicit trigger (user asks how search traffic is doing over a named period such as the last 28 days) and routes to alternatives with their own conditions: compare_periods for two named date ranges, get_search_analytics for raw rows. Nothing 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety and repeat-call profile is fully covered by structured data. The description adds only a scope note ('one property') and no behavioral detail such as error behavior for unknown URLs, permission requirements for reading permission levels, or rate limits. Moderate credit because the annotation bar is already met.

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

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

Three short sentences with no filler: what it reads, when to use it, and the fallback tool. The critical purpose sentence is front-loaded and the alternative routing comes last.

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

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

There is no output schema, so the description must convey the return surface, and it does by naming the three fields returned (type, permission level, verification state). Combined with the annotated safety profile and a fully documented single parameter, 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?

Schema description coverage is 100% and the single siteUrl parameter is documented with two concrete format examples, so the description does not need to explain it. The phrasing 'the property URL is not known yet' reinforces that siteUrl is the identifier but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb ('Read') and resource ('one Google Search Console property') and enumerates exactly what it returns: type, permission level, and verification state. That enumeration distinguishes it from sibling readers like get_sitemap_details and inspect_url without needing 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 an explicit positive condition ('when the user names a specific site and wants to know how that property is registered') and an explicit alternative with its triggering condition ('Call list_properties when the property URL is not known yet'). Both when-to-use and when-to-use-something-else are covered.

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, openWorld, so the safety profile is covered. The description adds that results are 'raw' and caller-controlled, but says nothing about rate limits, quota consumption, pagination, or latency, which matter for a raw analytics query. Adds some value over the annotations but not rich behavioral context.

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

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

Three sentences, front-loaded with the core capability followed by routing. The four sibling references are dense but each earns its place by disambiguating. Slightly list-heavy but no filler.

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

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

For a 9-parameter tool with no output schema and annotations covering the safety profile, the description supplies enough for correct selection and invocation. It stops short of describing the shape of returned rows (dimensions/metrics), which an agent calling a raw query would benefit from knowing, but the rest is complete.

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

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

Schema coverage is 89%, so the schema already documents nearly every parameter including the nuanced dataState tradeoff. The description merely echoes the parameter categories without adding syntax or format meaning beyond the schema. 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 states a specific verb and resource ('Query raw Google Search Console search analytics') and enumerates the controllable facets (dates, dimensions, filters, search type, row limit, data state). It clearly distinguishes itself from the shaped report siblings by positioning as the raw/custom-breakdown tool.

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?

Explicit routing: 'Use when the user needs a custom breakdown that the shaped reports do not offer,' then names three alternatives (get_performance_summary, get_top_queries/get_top_pages, compare_periods) with the exact condition that selects each. This is textbook when-to-use guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior, so the safety profile is covered. The description adds real behavioral context by disclosing what the response contains (type, last download, counts, error/warning totals), which is the main thing an agent needs beyond the annotations.

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

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

Three tight sentences with no filler, front-loading the purpose before the usage guidance and the sibling routing hint. 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?

With no output schema, the description carries the burden of describing return values and does so concretely. Combined with full schema parameter coverage and annotations covering safety, an agent has everything needed to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, and both parameters (siteUrl, feedpath) are fully documented in the schema itself, so the schema does the heavy lifting. The description adds no format or syntax guidance beyond it; 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 (Read) and resource (one submitted sitemap) and enumerates the returned fields (type, last download, URL counts by content type, error/warning totals). It is immediately distinguishable from list_sitemaps, which returns collections rather than one feed's detail.

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?

Explicitly states when to use it ("when the user names a sitemap and wants its processing status") and names the alternative plus its triggering condition ("Call list_sitemaps when they do not yet know which feed to open"). Nothing 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 readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so safety, repeatability, and external dependence are fully covered by structured data. The description's only added behavioral detail is that results carry a CTR benchmark score per position, which is useful but thin. It says nothing about permissions, quota, or data freshness for a live Search Console call, so there is no credit above baseline.

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

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

Three sentences, no filler, and the capability statement is front-loaded ahead of the routing advice. The routing sentence is dense with three sibling names, but each pairing of tool and condition earns its place rather than padding.

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 still discloses the shape of the result (pages ranked by clicks, each scored against a position CTR benchmark), which is the key return-value context an agent needs. Defaults and enum values live in the schema, and safety is covered by annotations, so the only minor gap is the absence of any note on scope or auth for the connected Search Console property.

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

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

Schema description coverage is 100% with six well-documented parameters including three enums, so the schema carries the full parameter burden. The description only gestures at ordering ('by clicks') and never explains limit, period, searchType, or device semantics. Baseline 3 is correct when the schema does all the work.

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 ('List the top Search Console pages by clicks') plus a distinctive second function ('score each page against the CTR benchmark for its position'). That benchmark-scoring behavior separates it cleanly from get_top_queries and the other list-style siblings without needing to open 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?

Gives an explicit triggering condition ('Use when the user asks which URLs earn the search traffic') and then routes to three named alternatives with the condition that selects each: get_top_queries for queries, get_traffic_by_device for a device split, find_ctr_opportunities for pages far below benchmark. This is textbook when/when-not/alternatives coverage.

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/openWorld, so the safety profile is covered. The description adds a genuinely non-obvious behavioral trait — that results are enriched with a CTR-vs-position benchmark score — which the schema does not express. It stops short of describing result shape or pagination, hence 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?

Three sentences, zero waste, correctly front-loaded: what it does first, then when to use it, then sibling routing. 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 convey the essential return content (ranked queries plus CTR benchmark scores). It omits result-count/pagination behavior, but annotations and the limit parameter largely cover the practical call 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% with 7 well-documented params (including enums for device, period, searchType), so the schema carries parameter meaning entirely. The description adds no filter semantics, syntax, or defaults beyond it. 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?

States a specific verb+resource ('List the top Search Console queries') plus a distinctive secondary behavior ('score each query against the CTR benchmark for its position'). This differentiates it from siblings like get_top_pages and find_quick_wins without needing their schemas.

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?

Explicit when-to-use ('when the user asks which queries bring traffic or which queries underperform their rank') plus explicit alternatives with routing conditions: get_top_pages for pages, find_quick_wins for opportunity buckets rather than a plain ranking. Nothing 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 cover safety (readOnly, idempotent, non-destructive, openWorld). The description adds that it returns four specific metrics split by three device categories, which is useful output context not present in the schema. It does not mention data freshness or row limits, but for a simple read-only tool this is a meaningful addition 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?

Three tightly written sentences: function, usage trigger, and alternative routing. The purpose is front-loaded and every sentence earns its place with no filler.

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

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

With no output schema, the description adequately explains the return values (clicks, impressions, CTR, average position by device). Together with the fully documented input schema and rich annotations, an agent has enough information to call it 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 description coverage is 100%, so the schema fully documents period, siteUrl, and searchType. The description adds no parameter-level syntax or constraints 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 ('Split') and resource ('Search Console clicks, impressions, CTR, and average position') plus the dimension (desktop, mobile, tablet). It distinguishes itself from siblings by naming get_top_pages and get_top_queries for drill-down needs, so an agent can tell it apart 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?

Explicitly says 'Use when the user asks whether one device is underperforming the others,' and routes adjacent needs to get_top_pages or get_top_queries. This gives both the trigger condition and alternative tool selection, leaving nothing 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 real behavioral context beyond that: it discloses the sequencing relationship with gsc_verify_site and the constraint that domain properties cannot use FILE or META. It stops short of return format or rate-limit details, but the added constraints are substantive.

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

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

Three sentences, each earning its place: purpose first, then usage/sequencing, then the domain-property exception. Front-loaded and free of repetition.

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 an output schema absent but a described return (the token plus placement steps), the definition covers purpose, preconditions, sequencing, and method constraints. An agent has everything needed to call it 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 baseline is 3, and the description adds genuine meaning on top. It explains the valid enum values in context and, critically, the constraint that domain properties must use DNS_TXT — semantics the schema's plain enum does 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?

The description states a specific verb (request) and resource (site-verification token) and enumerates the four supported methods. It clearly distinguishes itself from the sibling gsc_verify_site by defining the token-fetching step that precedes verification.

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 says when to use it ("when the user needs the token before they can prove they own a site") and when to call the alternative ("Call gsc_verify_site only after the token is in place"). It also gives a method-selection rule for domain properties, leaving nothing 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 it is not read-only, is idempotent, and is non-destructive, so safety is covered. The description adds real behavioral context beyond that: it presupposes the token is already published and clarifies that property creation is out of scope. It does not describe failure modes (e.g., what happens if the token is not yet present or verification fails), which keeps 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?

Three sentences, front-loaded with the action and its precondition, then the trigger, then the negative scope. Every sentence carries information an agent needs; no filler.

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

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

The tool is a simple two-parameter mutation with full schema coverage and no output schema. The description supplies the prerequisite chain and the sibling boundary, which are the only things the structured fields don't already say. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% and the method enum is documented inline, so the schema carries the parameter burden. The description mentions the four verification modes in the usage sentence but adds no syntax or format guidance beyond what the schema already provides. 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 ('Record Google site ownership') with scope ('for a URL or a domain') and explicitly separates itself from the sibling add_property by saying it does not add the property. An agent can distinguish it from get_verification_token and add_property 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?

Gives an explicit trigger ('use when the user says the file, DNS record, meta tag, or Analytics tag is published'), a prerequisite stage ('call gsc_get_verification_token first if they do not have a token yet'), and a negative boundary ('this does not add the Search Console property; call add_property for that'). Nothing 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 real behavioral value by disclosing what is examined (coverage, mobile usability, rich-result verdicts) and that failure detail is included. It stops short of noting auth requirements or any inspection latency, so it is strong but not exhaustive.

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

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

Three sentences, each doing distinct work: what is inspected, when to use it, and which siblings cover adjacent cases. No redundancy and the scope statement 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?

There is no output schema, yet the description describes the returned verdict categories and issue detail, so an agent knows what to expect. Purpose, trigger, and sibling routing are all present for a simple two-parameter read 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% with only two parameters (siteUrl, url), and the schema already explains the exact siteUrl format and that url must be fully qualified. The description adds nothing parameter-specific, 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 (inspect) and a tightly scoped resource (one URL in the Google Search Console index) and enumerates exactly what verdicts are returned. It is immediately distinguishable from batch_inspect_urls and check_indexing_issues by scope.

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 an explicit trigger ('when the user asks why a single URL is missing from search or looks wrong') and names both alternatives with the conditions that select them: batch_inspect_urls for a list, check_indexing_issues for auditing top traffic pages.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds useful context beyond that: it claims to return ALL accessible properties and discloses that property type and permission level are surfaced. It omits pagination or credential-scope caveats, so it's strong but not exhaustive.

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 core action and scope, then usage, then sibling routing. Three tight sentences with no waste, each adding distinct value.

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 rich annotations, the description covers everything an agent needs: what it returns (property type, permission level), when to reach for it, and which siblings to use instead. Nothing essential 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?

There are zero parameters, so there is nothing to document; the baseline for a no-parameter tool is 4. The description correctly implies the tool is unfiltered and scoped only by credentials, which is the relevant semantic for invoking 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?

States a specific verb (list) and resource (Google Search Console properties) with scope ('every... the credentials can access') and even enumerates what's included (property type and permission level). It distinguishes itself from get_property_details and add_property by name, so an agent can identify it without opening any schema.

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

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

Explicitly says when to use it ('when the user wants to see which sites they can query before choosing one') and routes to alternatives: get_property_details for a single known property and add_property only for registering a new site. This is a full when/when-not/alternative treatment.

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 what the agent actually receives back (status, URL counts, error flags), which is meaningful since there is no output schema, though it says nothing about pagination or permission 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?

Three short sentences, front-loaded with the action and return content, then the routing guidance. No filler and 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 only one required parameter and no output schema, the description covers action, returned fields, and the two sibling alternatives an agent would otherwise have to guess between. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100% and the single siteUrl parameter is fully documented in the schema, including the sc-domain format example. The description's 'one Google Search Console property' phrasing reinforces the scope but adds no syntax or format detail 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?

States a specific verb (List) and resource (sitemaps submitted for one GSC property), plus the scope of returned data (status, URL counts, error flags). It is clearly distinguishable from get_sitemap_details, which opens a single feed.

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?

Explicitly names the trigger condition (user asks which sitemaps are filed or whether Google reports problems) and routes to two named alternatives with their own conditions: get_sitemap_details for opening one feed and submit_sitemap only when filing.

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, so the safety profile is covered; the description adds the genuine behavioral detail that the result is a graded score composed of traffic trend, CTR efficiency, position distribution, and sitemap health. It doesn't mention permissions, cost, or rate limits, but given the strong annotation coverage this extra context is solid rather than exceptional.

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

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

Three sentences, all load-bearing: purpose and output shape first, then usage, then sibling routing. No redundancy and the most important information 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 no output schema, the description carries the burden of explaining return values, and it does so by naming the grade plus the four sub-score dimensions. Combined with annotations covering the safety profile and a complete schema, an agent has everything needed to call it 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 description coverage is 100% with only two parameters, so the schema fully documents siteUrl (including the sc-domain: form) and the searchType enum. The description adds no parameter-level syntax or format guidance, making the baseline 3 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 (score) and resource (Search Console property) and even names the output shape: an A–F grade with four named sub-scores. An agent can distinguish this from grade-free siblings like get_performance_summary or weekly_seo_report 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?

Explicit when-to-use ('user asks how healthy the site is in search or wants a grade') plus two named alternatives with the exact condition that selects each (weekly_seo_report for narrative, find_declining_content when traffic drop is already known). Nothing 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 cover the safety profile (idempotentHint=true, destructiveHint=false, openWorldHint=true), so the description only needs to add non-obvious behavior. It does: resubmission refreshes rather than duplicates and does not delete anything, which directly reinforces the idempotency guarantee in human terms. It stops short of disclosing failure modes (invalid/unauthorized sitemap) or rate limits, so it isn't 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?

Three tight sentences: purpose, when-to-use, and sibling routing. No filler, and the core action 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?

For a two-parameter, non-destructive mutation tool with annotations and full schema coverage, the description supplies everything an agent needs: the action, the trigger, idempotency/refresh behavior, and the two adjacent tools. No output schema exists, but for a submit-and-acknowledge operation that 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 coverage is 100%, with both siteUrl and feedpath thoroughly described (including the sc-domain: format). The description adds no parameter-level detail beyond what the schema provides, 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 (Submit) and resource (sitemap URL) plus the target system (Google Search Console), and explains the effect: 'so Google can discover the pages of that property.' This distinguishes it clearly from siblings like delete_sitemap and get_sitemap_details.

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?

Explicitly names the trigger scenario ('when the user has published or moved a sitemap and asks to file it') and routes the agent to both relevant alternatives: delete_sitemap to withdraw, get_sitemap_details to verify processing. Nothing 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 the safety profile (readOnly, idempotent, non-destructive), so the bar is lower. The description adds genuine behavioral context by promising a "one-call" aggregation and enumerating the composite outputs, signaling it fans out over multiple data sources in a single invocation. It omits any statement of cost/latency or auth prerequisites.

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

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

Three sentences, zero waste. The capability statement is front-loaded, followed by the trigger and the routing alternatives in priority order.

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

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

There is no output schema, but the description compensates by enumerating exactly what the digest returns, and it routes to the correct sibling for narrower needs. Nothing essential to selecting or invoking the tool is missing.

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

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

Schema description coverage is 100%, so both parameters (siteUrl, searchType) are already documented in the schema. The description adds no additional parameter meaning, 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 opens with a specific verb+resource ("Build a one-call weekly SEO digest") and enumerates the exact contents (traffic vs last week, growers, decliners, quick wins, sitemap health, recommendations). An agent can distinguish this composite report tool from siblings 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?

It states the trigger ("Use when the user asks for a weekly report or a regular status update") and names two alternatives with the conditions that select them: seo_health_check for a letter grade, get_performance_summary for headline numbers only. This is explicit when-to-use and when-to-prefer-other guidance.

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