Murkuz SEO

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

No annotations provided, so the description carries the burden and does substantial work: it discloses the 28-day fixed window, that changes require stored history covering both windows, that combined average position is intentionally null, that negative change_percent means better, and that pagination is effectively absent (truncated:false). It does not describe response shape beyond the pagination block, but the disclosure load is real.

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 first sentence is good, but the paragraph is dense and mixes several topics (source semantics, window math, position change direction, Bing sub-signals, pagination) without structure. Much of it is valuable, but the traversal is heavy for a 1-parameter tool.

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

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

For a read-only overview with one optional enum param, no annotations, and no output schema, the description covers the important non-obvious behaviors an agent needs: fixed windows, history-dependent change, null combined position, direction of change_percent, and pagination semantics. Missing only a note on return shape or how siblings differ.

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 enum values are self-explanatory, so baseline 3 applies. The description does add meaning beyond the schema: it explains the 'honest merge' semantics behind 'combined/ all', the fixed window shared across engines, and the Bing position quirk, which are genuinely parameter-adjacent nuances.

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 precise verb and resource: 'side-by-side performance summary for all of the user's sites.' Clear on the scope (all sites, not a single site) and distinguishes itself from per-site siblings like Site_Analytics. Doesn't explicitly name sibling Portfolio_Comparison, which is the nearest overlap.

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

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

Explains what 'combined' vs 'google' vs 'bing' means and describes the default, but gives no guidance on when to prefer this overview versus Search_Analytics, Portfolio_Comparison, or a per-engine tool. The 'which is how you can tell this from a first page' line hints at when to reuse it, but there is no explicit when-to-use/when-not.

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

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

With no annotations, the description carries the full burden and does it well: it discloses the hard cost (9 credits per call, independent of seed count), the absence of offset/paging and why, and the critical semantic that a full-length response is capped rather than complete. These are exactly the non-obvious traits an agent would otherwise have to discover by wasting credits.

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 value proposition and cost, and nearly every sentence earns its place. The final two cap sentences overlap somewhat ('no offset or paging' vs. 'capped, not complete ... call again'), a mild redundancy in an otherwise efficient block.

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 and no annotations, yet the description supplies the returned fields, the cost model, the cap/paging semantics, and the batching strategy. Nothing an agent needs to invoke this correctly and cheaply 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 the baseline is 3; the description adds real meaning by tying `limit` to billing and explaining that it is not a page-size parameter (no second page exists) and should instead be raised to the max. It also implies batching many seeds into `keywords` to amortize cost, though it doesn't restate country/language fallback behavior.

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

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

States a specific resource (Bing's own related keywords for seed terms) plus the returned metrics (volume, competition, CPC), and explicitly distinguishes itself from the sibling Keyword_Ideas by noting Bing's different long-tail phrasing. An agent can route between the two without opening either 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 explicit when-to-use guidance ('run alongside Keyword_Ideas rather than instead of it'), a batching rule ('batch them into one call' since cost is fixed per call), and a paging rule ('raise the row count in a SINGLE call ... rather than calling again'). Both the alternative and the conditions selecting it are named.

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?

No annotations are provided, so the description carries the full behavioral burden. It does strong work disclosing the 9-credit flat cost regardless of keyword count, the 200-keyword hard cut that silently drops the tail, and the absence of paging. It does not state auth/prerequisite requirements or the exact shape of returned rows beyond the four metric families, leaving some gaps. With no annotations to lean on, this robust but incomplete disclosure lands at the low end of adequate.

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-loads purpose, then cost, then the cap, then the no-paging fact. Dense but every clause carries information. The one weak sentence is 'Compare the rows returned against the keywords you sent,' which is an inferable admonition rather than a fact.

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 annotations, the description compensates by covering cost, the 200-row cap and truncation behavior, and the absence of paging. An agent can decide whether to call it, how to batch, and how to interpret a short return list without further information.

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

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

Schema coverage is 100%, so the schema itself documents country/language/keywords, giving a baseline of 3. The description adds genuine operational meaning for the keywords parameter (batch all keywords into one call; the effect is identical whether you send 1 or 200), which is not in 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 and resource: Bing search volume, competition, CPC, plus monthly history, for up to 200 keywords. It is clearly distinguishable from sibling Keyword_Metrics (non-Bing) and Bing_Keyword_Ideas (ideation vs. metrics) without opening either 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 explicit when-to-use conditions: when a site draws meaningful Bing traffic (verifiable via the named sibling Bing_Search_Performance), or when the audience skews Windows/Edge. Names the alternative tool and the signal that routes to it.

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

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

With no annotations, the description carries the full burden and does so richly: it discloses the 9-credit per-call cost, that every call is billed, that there is no offset/paging because a second page would be a second charge, and that an exactly-full result set is capped rather than complete. It even prescribes the workaround (raise the row count in a single call). This is exactly the operational context annotations would otherwise 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?

Front-loads what the tool returns before moving to usage, cost, and the paging caveat. Every sentence adds operational value; nothing is redundant given the absence of annotations.

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

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

No output schema exists, and the description fully covers the return shape (keywords plus a 0–1 relevance score), the cost model, the truncation semantics, and the correct workaround. Nothing an agent needs to invoke and interpret this 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 the baseline is 3. The description exceeds that by explaining the semantics of 'limit' beyond the schema: results are capped at the requested count and a full-page response signals truncation, not completion, with the instruction to raise the count in one call rather than page.

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: 'keywords Bing associates with one specific page.' The phrase 'one specific page' explicitly differentiates it from sibling tools like Bing_Site_Keywords and Bing_Keyword_Ideas, which operate at other scopes. An agent can select this 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 a concrete usage context ('Point it at your own article...') and explains the diagnostic value of a focus-keyword mismatch. However, it never explicitly names which sibling to use instead when a page-level Bing keyword view is the wrong choice, so the routing guidance is implicit rather than complete.

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

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

With no annotations, the description carries the full burden and does so well: it discloses first-party credentials, zero credit cost, the fixed rolling-snapshot caveat for position/CTR that is never window-matched, and that days_covered can be shorter than requested. Pagination semantics (truncated, next_offset, per-list paging) are also spelled out.

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 purpose and the sibling contrast, then moves to caveats and paging. It is on the long side and the PAGING block partly restates the schema's offset description, but every sentence carries operational 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?

No output schema exists, yet the description explains the return shape (metrics fields, top queries/pages lists, pagination block with returned/total_available/truncated/next_offset) and warns against drawing totals from truncated slices. An agent has everything needed to call and interpret it.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: it clarifies that limit and offset apply to both returned lists and that each list gets its own pagination entry and next_offset. It does not add much on site_id or days beyond what the schema 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 ('Read') and a specific resource set (clicks, impressions, CTR, average position, top queries, top pages) scoped to the caller's own connected Bing Webmaster property. It also explicitly distinguishes itself from the Bing_Keyword_* siblings by naming the different question they answer.

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 rule ('whenever the question is about how a site the caller owns is actually performing on Bing') and names the alternative tools plus the condition that selects them (third-party estimates, cost credits).

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

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

With no annotations, the description carries the full burden and does so well: it discloses cost (9 credits per call), that there is no offset/paging because each call is billed, and the critical semantic that a row count equal to the requested limit means capped-not-complete. It also prescribes the remedy (raise limit in a single call). This is exactly the behavioral context annotations would otherwise supply.

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 alternative, then cost and cap behavior. It is on the longer side, but nearly every clause carries operational value (cost, billing-driven no-paging, capped-row interpretation). Slightly dense, though nothing is clearly 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?

No output schema and no annotations, yet the description covers purpose, returned metrics, cost, and the pagination/capping behavior an agent must understand. It stops short of describing the response shape in more detail (e.g., per-row fields), which is the only remaining gap for a tool whose return format is otherwise unstated.

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

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

Schema description coverage is 100%, so all five parameters including limit, domain, country, and language are already documented. The description reinforces the limit semantics ('raise the row count ... up to its maximum') 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?

States a specific resource (keywords Bing associates with a whole domain) and enumerates the returned metrics (volume, competition, CPC). It distinguishes itself from the sibling Keyword_Rankings and implicitly from URL-scoped tools via 'whole domain', so an agent can place 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 names the when (point it at a competitor for their footprint) and the when-not with an alternative (own site -> Keyword_Rankings with source='bing', which is real connected-account data and free). 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?

With no annotations, the description carries the full behavioral burden and does so: it discloses the 3-credit cost, the row cap semantics (a full-page response is capped, not complete), the absence of offset/paging and the billing reason behind it, and the recommended remedy of a single larger call. This is unusually rich disclosure for a billed read tool.

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 and output, then routing, then cost, then the cap caveat. Every sentence earns its place, though the cap/paging explanation is dense and could be tightened without losing meaning.

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

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

No output schema exists, so the description must convey return content, and it names the exact fields (search volume, difficulty, their position, estimated traffic). Combined with the cost, cap, and input-routing guidance, 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. The description adds meaning beyond the schema by explaining the site_id/your_domain relationship (site_id auto-resolves your domain; otherwise pass your_domain) and by tying the row-count advice to the limit parameter, which the schema documents only as a max.

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 what a competitor ranks for that you don't') and specifies the exact output set ('every keyword where they appear and you do not appear at all'). It distinguishes itself from siblings by contrasting with Search Console's own-property limitation and referencing SERP_Snapshot as a source of competitor domains.

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 how to select the competitor (one you know you compete with, or a repeat domain from SERP_Snapshot), how to identify your own site (site_id vs your_domain), and why Search Console cannot substitute. The when-to-use conditions and the alternative source are all spelled out.

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

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

With no annotations, the description carries the full behavioral burden and does disclose the critical edge case: unconnected or never-synced sources return null, and null means 'no data yet' rather than 'no traffic'. It omits anything about auth/connection requirements or refresh frequency, but the null semantics are the trait an agent most needs.

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

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

Two tight sentences with zero filler; the return scope is stated first and the null caveat second. Every clause earns its place.

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

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

There is no output schema and no annotations, so the description must explain the return, and it does by defining the timestamp-per-source shape and the null convention. The only gap is the unexplained site_id, which an agent needs to supply.

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

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

Schema description coverage is 0% and the single parameter site_id is undocumented in both schema and description. The description never explains what site_id is, its format, or where to obtain it (e.g. from My_Sites), so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Get the last sync timestamp') and enumerates the exact sources covered (gsc, ga4, bing), so the agent knows precisely what is returned. It is unmistakable against analytics-oriented siblings like Search_Analytics or Site_Details, none of which report sync freshness.

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

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

The purpose implies when it is useful (checking data freshness before trusting a report), but the description never states when to call it, when not to, or which alternative to prefer. No sibling is named or excluded, leaving usage 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?

With no annotations provided, the description carries the full burden and does meaningfully disclose behavior: a one-hour cache per site+URL and the reason (tighter quota than Search Analytics), plus that repeats within the hour return cached data instead of spending quota. It omits prerequisites such as whether site_id must be a verified Search Console property and what happens for URLs outside the property.

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

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

Front-loaded with the payload summary, then a single supporting sentence on caching and quota. Dense and largely waste-free, though the quota rationale is slightly verbose for a definition.

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

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

With no output schema and no annotations, the description helpfully enumerates the returned fields, which is the right compensation for a read-only inspection tool. The main gap is the unexplained site_id and unstated authentication/property-verification requirement for a 2-parameter 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 coverage is 50%: 'url' is documented in the schema, but 'site_id' has no description anywhere, and the description never clarifies what site_id is (a verified Search Console property identifier) or its accepted format. The phrase 'per site and URL' hints at scoping for caching but does not compensate for the undocumented parameter.

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

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

The description gives a specific verb+resource ('What Google currently knows about one URL') and enumerates exactly what is returned: index status, last crawl, canonical mismatch, robots, mobile usability. It is clear and concrete, though it only mentions the sibling Search Analytics for a quota comparison rather than as a routing alternative.

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

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

Usage is implied by the content listed (you call this when you need Google's index/crawl view of a single page), and the quota/caching note hints at cost-conscious usage, but there is no explicit when-to-use guidance or differentiation from siblings like Landing_Page_Diagnosis or SERP_Snapshot that an agent might otherwise pick.

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

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

With no annotations, the description carries the full burden and does so exceptionally: it discloses the 2-credit cost for the default 50 ideas, that every call is billed, that there is deliberately no offset/paging, and the critical trap that a full-length response is a cap rather than a complete result. It also explains the remedy (raise the row count in a single call up to the maximum), which is exactly the behavioral context an agent needs to avoid double-charging itself.

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

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

The purpose and output shape are front-loaded, and the cost/cap guidance comes before the operational warning. The cap explanation is slightly redundant across three sentences ('no offset or paging', 'capped, not complete', 'raise the row count in a SINGLE call'), but each repetition is defensible given the billing consequences.

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 4-parameter read tool with no output schema, no annotations and no enums, the description supplies everything needed: returned fields, ordering, cost model, default size, cap behaviour, and the follow-up tool. An agent can call this correctly and interpret a full-length response without any external context.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real meaning about the limit parameter: it is a hard cap, not a page, and it must be raised within one call rather than iterated. Country and language semantics (including the fallback to 'us') remain in the schema only, which keeps it below a 5.

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

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

Specific verb+resource ('Returns related keywords around a seed term') plus the exact output fields (volume, difficulty, competition, intent) and sort order, so an agent knows precisely what comes back. It does not, however, distinguish itself from the sibling Bing_Keyword_Ideas, which appears to do a similar expansion job, so it falls short of a 5.

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

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

Gives clear context ('Use it to decide what is worth covering') and names the natural follow-up tool, Keyword_Rankings, with the condition that selects it. It offers no exclusion or comparison against the Bing keyword siblings, so a 5 is not warranted.

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?

No annotations exist, so the description carries full behavioral burden and does so richly: cost (2 credits for a typical 50-keyword lookup), a 100-row cap that silently drops the tail, non-paging billing model, and the advice to reconcile returned rows against keywords sent. This is exactly the disclosure an agent needs to avoid surprising costs or lost data.

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 value proposition, then cost/batching, then the cap caveat, then paging. Dense and mostly waste-free, though it is on the long side and interleaves cost, cap, and paging guidance rather than grouping them tightly.

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 fully describes the return shape (volume, difficulty, CPC, intent category, 12-month history) and covers cost, caps, and paging. Nothing an agent needs to call 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 description coverage is 100%, so country, keywords, and language are already documented (including the fallback behavior for country). The description adds no syntax or format detail beyond reiterating the 100-keyword ceiling, so baseline 3 is appropriate.

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

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

States a specific verb+resource ('Find out whether a keyword is worth writing about') and enumerates exactly what it returns (search volume, difficulty 0-100, CPC, search intent, 12-month history). It explicitly distinguishes itself from Keyword_Rankings for keywords the site already ranks for, so an agent can route correctly without opening 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 ('keywords the site does NOT already rank for') and names the alternative ('Keyword_Rankings has measured data and is free'). It also gives a strong operating rule ('always batch them rather than calling once per keyword, as the cost is mostly per call'), covering both selection and invocation.

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

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

With no annotations, the description carries the full burden and does so unusually well: it discloses that Google rows use date_range while Bing uses a rolling window, that clicks are deliberately NOT summed across engines, that total_available reflects a capped synced snapshot (a floor, not the true count), and that truncated=true means the rows are a slice. These are non-obvious behavioral caveats not derivable from the schema.

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

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

Front-loaded with the purpose before the dense caveats, and the 'PAGING:' marker gives some structure. The volume is justified by the number of real caveats, though several sentences are long and tightly packed, and it reads as a single wall of text rather than cleanly segmented blocks.

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 annotations, the description supplies what those would normally carry: the shape of the per-source response (google.rows/bing.rows), the pagination fields (returned, total_available, truncated, next_offset), and the paging recipe. An agent has everything needed to call and interpret 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 60%, so the description must compensate and largely does: it explains source defaults and the 'all' alias, couples date_range to Google rows specifically, and ties offset to the response's next_offset. The only gap is site_id, which is undocumented in both schema and description.

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

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

The opening sentence states a specific verb+resource ('Get top keyword rankings for a site') and the rest narrows the scope by source. It is clear and unambiguous, but it never names or contrasts a sibling such as Keyword_Metrics or Bing_Keyword_Metrics, so an agent must infer tool selection from surrounding naming alone.

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

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

Gives explicit when-to-use guidance across the branching parameter ('source' defaults to 'combined'; use 'google' or 'bing' for a single engine; 'all' is a back-compat alias), which is the tool's main decision point. It does not address when to choose this tool over the sibling keyword/analytics tools, so it stops short of the full 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?

With no annotations, the description carries the full burden and does well on output behaviour: it explains that only the query list is paginated while competing_pages and active_insights come back in full, and that the pagination block reports returned/total_available/truncated/next_offset. It stops short of stating permissions, read-only nature, or data-freshness characteristics.

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

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

The first sentence front-loads the full contents of the response, which is the right priority. The PAGING paragraph partly restates the earlier note that limit/offset page only the query list, so there is mild redundancy, but the rest is purposeful and well-structured.

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 tool with no output schema and no annotations, the description does the heavy lifting: it describes the returned data groups and the full pagination contract, including the truncated-flag warning. It leaves unstated how to interpret the insights/cannibalization payloads and any freshness caveats, but an 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 coverage is already 80%, so the baseline is 3, but the description adds real meaning by clarifying that limit/offset apply only to the query list and that offset should be fed the value from pagination.<list>.next_offset. It adds little on url/days/site_id beyond what the schema documents.

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 opening sentence names a specific resource (a single landing page) and enumerates exactly what the call returns: Search Console performance, GA4 behaviour, query cannibalization, and active insights. This aggregation scope distinguishes it from narrower siblings like Inspect_URL or Live_Cannibalization without needing to name them.

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

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

It gives a clear decision context ('Use this before deciding whether a page needs a content fix, a consolidation, or is simply fine'), which tells the agent when to reach for it. It does not, however, name any alternative tool or state when NOT to use it versus siblings such as Inspect_URL or Search_Analytics.

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

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

With no annotations, the description carries the full burden, and it delivers real behavioral insight: Google returns the entire list, so the pagination block always reports truncated=false, which is how an agent distinguishes a complete list from a first page. It omits auth/permission requirements and read-only confirmation, but the pagination disclosure is unusually valuable.

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 resource and payload, then the pagination caveat. The second sentence is slightly dense but every clause carries information an agent needs.

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 and no annotations, so the description must cover returns itself; it does so by naming the fields and explaining pagination behavior. The remaining gap is the meaning of site_id, which is unaddressed.

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

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

Schema description coverage is 0% for the single required parameter site_id, and the description says only 'this property' without clarifying what form site_id takes or where it comes from. The description does not compensate for the coverage gap.

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

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

States a specific verb+resource (sitemaps for a property) and enumerates the return payload (pending state, warnings, errors, indexed URL count), so an agent knows exactly what it gets. It does not name its write counterpart Submit_Sitemap, so sibling differentiation is left implicit.

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

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

There is no when-to-use guidance and no reference to alternatives, including the obvious sibling Submit_Sitemap. The second sentence explains result shape, not when this tool is the right choice.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that every call hits Google live, that positions are impression-weighted rather than rank-tracker ranks, that deep positions rest on sparse data, that absolute positions are directional only, and that the response is a paginated slice whose truncated flag invalidates aggregate conclusions. These are exactly the behavioural traits an agent cannot get 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?

The purpose is front-loaded and the labelled POSITION and PAGING sections make the caveats easy to scan. It is dense but slightly overweight on pagination semantics that the schema already specifies, so a small amount of text does not earn 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 5-parameter live-query tool with no annotations and no output schema, the description covers cost, metric semantics, data sparsity and pagination honesty, which is most of what an agent needs. It never describes the row contents (the competing pages/URLs and their metrics) nor the meaning of site_id, leaving a modest gap on return shape.

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

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

Schema description coverage is 80%, so the schema already documents days, limit, offset and min_impressions including defaults and the next_offset convention. The description's PAGING block largely restates that contract rather than adding parameter meaning, 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?

It states a specific phenomenon — queries where two or more of the site's own pages compete and split ranking signal — which is a concrete verb+resource definition rather than a restatement of the tool name. The concept is distinct enough from siblings like Live_Content_Decay, Live_Quick_Wins and Keyword_Rankings that an agent can route to 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?

Usable context is implied by 'Goes to Google on every call' (live, costly) and by the framing of cannibalisation as the diagnostic target, so an agent can infer when it fits. However, no sibling is named as the alternative and no explicit when-not condition is given, so guidance stays implicit rather than directive.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the live triple-window fetch, the performance cost, the paging model, and warns that conclusions drawn from a truncated slice are wrong. It omits auth/permission needs, but for a read analysis tool that is minor.

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?

Purpose is front-loaded, then the cost warning, then a clearly-labeled PAGING block. It is slightly long-winded in the pagination explanation, but every sentence informs correct invocation 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?

No output schema exists, so the description must explain return shape; it does so by naming the pagination fields (returned, total_available, truncated, next_offset) and interpreting truncated. Combined with the schema's parameter docs, an agent has enough to call and page correctly, with the missing site_id definition the main gap.

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

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

Schema coverage is 75% and documents limit/offset/min_clicks defaults. The description adds meaning by explaining the pagination contract (next_offset, raising limit) and how totals relate to paged rows, which the schema alone does not convey. site_id remains undocumented in both places.

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

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

States a specific verb+resource: identifies pages whose clicks fall across both of two consecutive 30-day windows, explicitly excluding single-period drops. This distinguishes it conceptually from siblings like Live_Traffic_Drops, though no sibling is named. The 'three-window slide' framing is concrete and unambiguous.

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

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

Offers a caution ('slowest tool in this module; run it sparingly'), which is real usage guidance about cost. However, it never says when to prefer this over alternatives such as Live_Traffic_Drops or Live_Quick_Wins, leaving tool selection 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?

No annotations exist, so the description carries the full behavioral burden and does so richly: it discloses that every call hits Google (cost/latency), that average position is impression-weighted across queries/devices/countries rather than a rank-tracker rank, that deep positions are sparse, and that absolute positions are directional only. The paging/truncation disclosure is exactly the kind of caveat an agent needs.

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-loads the purpose before the POSITION and PAGING caveats, and the labeled sections make it scannable. It is dense, but each clause (impression-weighting, sparse deep positions, truncated flag) carries operational value rather than 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 annotations, the description still covers live-computation behavior, data-quality caveats, alternatives, and pagination mechanics including the truncated/next_offset contract. The only gap is that it doesn't enumerate the actual row fields returned, though it fully explains the pagination wrapper.

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 80%, so the baseline is 3. The description adds meaning beyond the schema by tying min_impressions to 'your own impression threshold' and by explaining the offset/limit relationship to the pagination block (next_offset, raise limit), which the schema alone does not contextualize.

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 and scope: it surfaces pages whose CTR is below half the depth-expected benchmark, computed live under the caller's own impression threshold. It distinguishes itself from the sibling Keyword_Rankings explicitly, so an agent can tell them apart without opening either 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 a clear routing rule: prefer Keyword_Rankings for a quick check on a preset window, implying this tool is for the live, threshold-tuned case. It also frames position deltas between periods as the preferred usage. Lacks an explicit 'when not to use' beyond that single alternative.

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

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

With no annotations, the description carries the full burden and delivers: it discloses latency/cost behavior (hits Google every call), that position is impression-weighted rather than a rank-tracker rank, that deep positions rest on sparse data, and that absolute positions should be treated as directional. It also spells out pagination semantics and the meaning of 'truncated' for drawing conclusions.

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?

Purpose is front-loaded and POSITION/PAGING headers organize the caveats well. It runs long for a single tool, but nearly every sentence contributes interpretation guidance or a routing rule, so the density is justified 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?

There is no output schema, so the description must explain returns, and it does: the pagination block fields (returned, total_available, truncated, next_offset) and how to interpret them are described. Combined with the threshold and position caveats, an agent has everything needed to call and read this tool correctly.

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

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

Schema coverage is 83%, so most parameters are already documented and a baseline of 3 applies. The description adds meaning beyond the schema by framing max_position/min_impressions as user-tunable thresholds and clarifying the limit/offset paging loop (pass next_offset, or raise limit), which is more than the schema alone conveys.

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: queries sitting just off page one with enough impressions to matter, and explicitly positions itself against the sibling SEO_Insights as the 'live, tunable counterpart'. An agent can distinguish it from the other ~30 opportunity 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?

Names the alternative (SEO_Insights) and the exact condition selecting this one: live Google data with user-set thresholds, at the cost of being slower. The tradeoff ('slower because it goes to Google on every call' vs 'thresholds are yours to set') gives the agent a clear routing rule.

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

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

No annotations are provided, so the description carries the full burden and meets it: it discloses cost/latency (two live windows per call), data-quality caveats (impression-weighted positions, sparse data at depth, treat absolutes as directional), and exact pagination semantics including the truncated flag and the consequence of ignoring it. This is behavioral context an agent cannot get from the schema.

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

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

The description is long but front-loaded with the purpose and then broken into clearly labeled POSITION and PAGING blocks, so an agent can skim to the relevant section. Nearly every sentence adds a distinct constraint, though the prose is denser than it needs to be.

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 annotations, the description compensates by describing the return shape (returned, total_available, truncated, next_offset per list) and the diagnosis categories, plus the interpretation caveats for positions and truncation. An agent has everything needed to call it and to read the result 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 75% and the schema already documents days, limit and offset, so the baseline is 3. The description adds real value beyond it: it explains that limit is ordered biggest-loss-first, that the response's total is the number an agent needs for a 'how widespread' question, and that offset should be taken from pagination.<list>.next_offset. Only site_id remains unexplained.

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

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

States a specific verb+resource and a precise scope: pages that lost clicks between the current window and the one immediately before, with a named diagnosis (ranking loss, CTR collapse, falling demand, mixed). It distinguishes itself from the cache-reading family by cost ('fetches two live windows per call, so it is slower'), but never names a specific sibling such as Live_Content_Decay or Live_CTR_Opportunities, so overlap with those live tools is left to inference.

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

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

Usage is only implied: the latency disclosure ('slower than the tools that read the synced cache') tells an agent this is the fresh-data option, and the paging instructions govern correct invocation. There is no explicit 'use this when X, prefer Y when Z' routing against the several other Live_* siblings, so guidance is adequate but inferential.

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?

No annotations are provided, so the description carries the full burden, and it does substantial work: it declares the operation is free ('this never consumes credits'), explains the budgeting purpose, and lists what is returned (credits remaining, monthly usage, refresh timing, per-action cost). It does not cover auth requirements or rate limits, but the key behavioral trait — that calling it is cost-free — is disclosed clearly.

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 purpose and followed by return contents and usage trigger. The middle sentence enumerating return fields is slightly list-heavy, but every sentence contributes routing or behavioral value rather than 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 zero parameters and no output schema, the description compensates by enumerating the return values (credits remaining, allowance used, refresh date, action costs). Nothing an agent needs in order to call this correctly and interpret the result is missing.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; the baseline for a 0-param tool applies. The description correctly implies a no-argument call by never referencing any inputs.

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

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

States a specific verb and resource: checking remaining research allowance/credits before running expensive work. This is clearly distinguishable from the many sibling tools that consume credits (Keyword_Ideas, Competitor_Gap, SERP_Snapshot) by being the budget-check endpoint. An agent can tell what this does 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 instructs 'Call this first before a large sweep across many keywords, competitors or pages, so you can budget the run rather than hitting the limit part-way through.' That is an unambiguous when-to-use trigger with the rationale, which is exactly what routing guidance should look like.

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

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

With no annotations, the description carries the full burden and largely meets it: it discloses the exact return shape, that no limit/offset exists, and that the pagination block reports truncated=false with a count so a complete list is distinguishable from a first page. It does not explicitly state the read-only/no-side-effect nature, but the verb 'List' makes that clear.

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 that are front-loaded with the resource and its fields, then usage, then pagination semantics. Slightly dense but every clause carries information; 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, so the description must explain return values, and it does so thoroughly (per-field contents, connections block, pagination block). Combined with the usage routing, an agent has everything needed to call and interpret the 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?

Zero parameters, so baseline is 4. The description goes further by explaining there is intentionally no limit or offset to pass and why, which adds useful meaning beyond the empty 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 and resource ('List every site on the account') and enumerates exactly what each entry contains (name, domain, public URL, default language, connections block with per-source connected flags and last-sync times). An agent can distinguish it from Site_Details or All_Sites_Overview 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 tells the agent to 'Start here to find the site_id every other tool needs, and to check a source is connected before asking for its data.' That is an unambiguous when-to-use directive tied to downstream siblings.

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

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

With no annotations to lean on, the description carries the full burden and does so: it discloses the median split points and that both medians are returned, explains why quadrants are skipped when the conversion axis has no signal (a zero median would mislabel every page including 'protect'), and states the exclusion rule for pages missing either data side.

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 purpose and the payoff framing, then behavior, then paging. It is long, and the PAGING paragraph partially restates the truncation point, but nearly every sentence adds a constraint an agent would otherwise get wrong.

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

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

With no output schema, the description must describe the return shape, and it does: quadrants_assigned boolean, the ranked_by_potential_only fallback list with an explanatory note, and the per-list pagination block reporting returned/total_available/truncated/next_offset. An agent has everything needed to call and interpret 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 75%, and the description adds real meaning beyond it: limit and offset apply per quadrant, so a quadrant of 80 is not mistaken for 20, and offset should be fed the response's next_offset. It doesn't clarify the days window semantics, which the schema already covers reasonably.

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 ('rank pages') plus the exact resource and the two axes being crossed (Search Console ranking potential vs GA4 conversion rate). The four quadrant names make it immediately distinguishable from siblings like Landing_Page_Diagnosis or Live_Quick_Wins.

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?

Clearly delineates the two operating regimes: when at least one page has a measured GA4 conversion versus when none do, and what changes in the response in each case. It does not name a sibling alternative to use instead, so it falls short of the explicit when/when-not/alternatives bar.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the path-based join (not raw string matching), the graceful 'not connected' GA4 result instead of zeros, and that total_clicks/total_impressions are summed over every query while top_queries is a slice. The pagination contract (returned, total_available, truncated, next_offset) and the warning that truncated=true invalidates totals is exactly the behavioural context an agent needs.

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 purpose and metrics, then the join caveat, then paging. It is dense but mostly earns its length; the truncated warning restates 'these rows are a slice' twice in one sentence, which is mild 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?

With no output schema and no annotations, the description compensates by enumerating the returned metric groups, explaining the totals-vs-slice semantics, and fully specifying the pagination block. An agent has everything needed to call it correctly and interpret the result.

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 80%, so the baseline is 3; the description goes beyond it by clarifying that totals are computed over the full query set rather than the returned page, and by tying offset to the response's pagination.next_offset. The url parameter's full-URL-or-bare-path flexibility is already in the schema, so there is no additional gain there.

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 ('See what a page ranks for and what visitors do once they land') and names both data sources it joins (Search Console queries beside GA4 behaviour) for a single page. This makes it clearly distinct from page-agnostic siblings like Search_Analytics and Site_Analytics without needing to name them.

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 clear operating context: it explains the URL-shape mismatch and how matching is done, and tells the agent to check truncated before concluding. It stops short of naming when to prefer a sibling (e.g. Landing_Page_Diagnosis or Search_To_Revenue) or any exclusion conditions, so it is clear context without 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?

With no annotations, the description carries the full burden and does so well: it discloses that partially-connected sites still appear with connected:false and a reason instead of being dropped, that the default page is 50, and it names the exact pagination fields (returned, total_available, truncated, next_offset). This is behavioral context well beyond what any structured field provides.

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?

Purpose is front-loaded, but the pagination caution is repeated three times (the second paragraph, the PAGING block, and the truncated warning), which is redundant. The signal is important but the same point is made more than once.

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 annotations, the description does substantial work explaining the connectivity fields and the pagination envelope. It still does not describe what a per-site health verdict actually contains (metrics, statuses), which is the core payload an agent would need.

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 days, limit and offset including defaults. The description restates the pagination mechanics rather than adding syntax or semantics the schema lacks, so the baseline of 3 applies.

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

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

States a specific verb and resource (runs the Search Console vs GA4 traffic health check) plus a precise scope (every site the caller owns that has both integrations connected). This implicitly separates it from the single-site Traffic_Health_Check, but it never names that sibling or any other alternative explicitly.

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

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

Provides operational guidance on how to interpret results (check pagination before claiming anything portfolio-wide, read the rest with offset). However, it gives no when-to-use / when-not guidance and never routes the agent to a sibling such as Traffic_Health_Check for single-site needs, so usage is only implied.

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

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

With no annotations, the description carries the full burden and does well: it discloses live-fetch latency vs the cached sibling, that total_available is null because the API does not report row counts, and the truncated/next_offset paging contract. It does not cover permissions or rate/quota limits, which are relevant for a live Search Console call.

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

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

Long but front-loaded and clearly segmented with POSITION and PAGING headers, so the routing guidance comes first. Dense rather than padded, though the paging paragraph could be tightened.

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 must explain return semantics, and it does: the pagination block fields, null total_available, truncated logic, and impression-weighted position interpretation. An agent has everything needed to call and interpret the result.

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 88%, so the schema already documents days, offset, filters, order_by, row_limit, dimensions and order_direction. The description reinforces offset/truncation behavior but adds little per-parameter meaning beyond what the schema 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+resource ('the raw cut of Search Console data') with the scope made explicit: any dimensions, filters, sort, fetched live for this call only. It names the sibling Keyword_Rankings and how it differs, so an agent can distinguish it without opening either 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 to prefer Keyword_Rankings when a preset window is enough and to reach for this only when the question needs a window, filter or dimension combination the cache does not expose. The alternative and the selecting condition are both named.

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

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

With no annotations, the description carries the full burden and does so unusually well: it names the estimated step in the chain, states that every response carries attribution_method: 'click_share_estimate' plus a note, defines what total_revenue covers, and warns that truncated must be checked before drawing conclusions. This is exactly the interpretive context an agent needs.

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 purpose, then the estimation caveat, then the paging block. Dense but nearly every sentence earns its place, though the attribution discussion runs slightly long and repeats the 'estimated step' idea.

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 and no annotations, so the description must supply return-value context, and it does: row semantics, pagination block contents, attribution_method field, and total_revenue scope. It stops short of describing the row-level fields (query, page, revenue columns) or how to obtain site_id.

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

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

Schema coverage is 75% (site_id undocumented) and the schema already explains days, limit and offset. The description earns extra credit by explaining the paging loop semantically (truncated, next_offset, 'a total built on these rows is wrong'), which goes beyond the field descriptions rather than restating them.

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

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

States a specific resource and scope: search queries tied to revenue for GA4 e-commerce sites, with revenue measured rather than estimated. It is clearly distinct from generic siblings like Search_Analytics or Page_Search_To_Behaviour, though it never names the adjacent revenue/behaviour tool it might be confused with. The verb is implied ('which queries are associated with...') rather than stated as an action.

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

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

Gives one strong precondition (site must have GA4 e-commerce tracking enabled) and detailed paging instructions, but no explicit when-to-use-vs-alternative guidance relative to the many sibling analytics tools. Usage is implied through scope rather than stated as a decision rule.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it explicitly declares 'This is a read: it reports what was found, it does not change anything on the site,' enumerates the fields each insight carries, and warns that rows may be truncated. It omits auth/permission requirements and rate-limit behavior, which keeps it from a 5.

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

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

It is front-loaded and dense with useful field semantics, but the pagination explanation is stated twice in nearly identical terms ('pagination.insights carries returned, total_available, truncated and next_offset' vs 'The pagination block reports returned, total_available, truncated and next_offset for every list'), and the long middle field-enumeration sentence is hard to parse. The redundancy costs it points.

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 explain the return shape, and it does: it lists the insight fields, names the pagination object keys, and warns that a 'none of them' conclusion on truncated rows is wrong. Only the site_id parameter and the meaning of 'evidence' are left unexplained, so it is nearly complete for a 7-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 coverage is 71%, and the description adds real meaning on top of it by enumerating the filter dimensions (insight type such as striking_distance/low_ctr/cannibalization, status, action_type, source) and giving an example of insight-type values. It also reiterates offset/next_offset paging and the option to 'raise limit,' though site_id and action_type value space remain undocumented.

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

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

The description gives a specific verb and resource: 'Read the findings Murkuz has already stored for a site from its synced Search Console data,' which scopes it well beyond the generic name SEO_Insights. It implicitly distinguishes itself from the Live_* siblings by stressing data that is 'already stored,' but never explicitly names an alternative tool, so it stops short of a 5.

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

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

It tells the agent how to interpret results ('Use confidence_label and potential_clicks to decide which findings are worth the customer's time') and lists the available filters, which implies usage. However, it never states when to prefer this over Live_CTR_Opportunities, Live_Cannibalization, or Opportunity_Matrix, and gives no prerequisites beyond the required site_id, so usage guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden and does so: it discloses the billing cost ('Costs 1 credit'), the silent country fallback, the no-paging/no-offset constraint, and crucially the cap semantics ('A response holding exactly that many rows is capped, not complete'). This is the kind of non-obvious behavior an agent could not infer from the schema alone.

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 purpose and return shape, then progressively layers usage, exclusions, cost, and the cap caveat. The length is justified because every sentence adds a distinct operational fact; there is no filler or restatement of the name.

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

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

There is no output schema, so the description must describe the return payload and it does (titles, descriptions, URLs, domains, SERP feature flags). Combined with cost, cap behavior, and operator limitations, an agent has everything needed to call this correctly and interpret the result.

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 defaults, ranges, and codes are already documented and the baseline is 3. The description adds genuine meaning on top: it explains that 'results' is a hard cap rather than a target, and instructs 'raise the row count in a SINGLE call, up to its maximum, rather than calling again', which the schema does not convey. The keyword constraint is duplicated from the schema, keeping it below a 5.

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 ('See who you're actually up against for a keyword. Returns the results on page one right now') and enumerates exactly what comes back: titles, descriptions, URLs, domains, and SERP features. It explicitly contrasts itself with Search Console ('it can never tell you who holds position 1'), so an agent can separate it from the ranking/reporting 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 concrete when-to-use triggers: 'before writing against a keyword', 'before rewriting a meta title for a Low-CTR insight', and 'to judge whether an AI overview is eating the clicks'. It also states a hard exclusion ('Search operators such as site: are not supported'), which prevents a common misuse. 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?

With no annotations, the description carries the full burden and delivers: real synced values (nothing estimated), the fact that only last_28_days syncs with other windows falling back to a snapshot plus a note, connected/synced flags, a units block explaining the 0-1 vs 0-100 discrepancy, and revenue only when e-commerce is enabled. It also warns that truncated=true makes totals or 'none' claims invalid, which is exactly the kind of caveat an agent needs.

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

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

The purpose and sibling distinction are front-loaded and each section is organized (purpose, differentiation, sync caveats, units, paging). However it is long and repeats the pagination concept across three separate passages ('one pagination entry each', 'PAGING', and the truncation warning), which costs some efficiency.

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 explain the return shape, and it does: per-list pagination entries, a pagination block with returned/total_available/truncated/next_offset, connected/synced flags, a units block, and conditional revenue. For a complex multi-metric tool, nothing an agent needs to call or interpret it 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 75%, so the baseline is 3; the description adds that conversion_events and daily_metrics are returned in full (unaffected by limit/offset) and that date_range values other than last_28_days fall back with a note. Combined with the schema's own sorting and next_offset guidance, the semantics are well covered, though most of the limit/offset scope detail is already present in 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 (Get) and resource (Google Analytics 4 traffic, engagement and conversion data) and then enumerates the concrete metrics returned, so an agent knows exactly what surface it covers. It explicitly contrasts itself with the Search Console tools, making it distinguishable from siblings like Search_Analytics and Keyword_Rankings 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?

Provides an explicit routing rule: use Search_Analytics or Keyword_Rankings for search performance and Site_Analytics for post-arrival behavior. It also gives conditional operational guidance (raise limit or read with next_offset when truncated is true), so the agent knows both when to pick this tool and how to consume it.

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

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

With no annotations, the description carries the full burden, and it does substantial work by disclosing the exact response payload, including the nested fact that connected data sources are returned with their last sync times (useful for judging freshness). It also implies a non-mutating lookup via 'Get'. It stops short of stating error behavior for an unknown site_id or any permission requirements, which are the only notable gaps.

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

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

Two sentences, fully front-loaded: the returned fields come first and the My_Sites shape reference is a compact second sentence that earns its place by anchoring the response format. No filler, no restating of the name or title.

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

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

With no output schema and no annotations, the description must convey the return contents, and it does so field by field, including the nested data-source sync times. The shape reference to My_Sites rounds it out, though the agent must already know that sibling's output to fully reconstruct the response, and invalid-ID behavior is unaddressed.

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

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

Schema description coverage is 100% and the single site_id parameter is already documented in the schema, so the baseline of 3 applies. The description adds only indirect context (that the ID selects one site whose details are returned) and no syntax, format, or lookup semantics beyond what the schema provides.

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

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

The description states a specific verb ('Get') and resource ('one site') and enumerates exactly what is retrieved: name, domain, public URL, default language, added date, and connected data sources with last sync times. It also explicitly relates itself to the sibling My_Sites ('Same shape as a row from My_Sites'), so an agent can distinguish the single-site lookup from the all-sites list without opening either 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?

Usage is implied rather than stated: the phrasing 'one site's' plus the reference to My_Sites makes it clear this is the single-record counterpart to the list tool, and the required site_id confirms the selection context. However, it never says when to prefer this over My_Sites, or what to do when only one site is known, so the guidance is inferable but not explicit.

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

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

With no annotations, the description carries the full burden and does well: it declares the mutation ('Writes to Google; this is the connector's only write') and explicitly rules out generation, hosting and editing. It still omits quota/rate-limit behavior and permission requirements, which matter for a submission endpoint.

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, with the core action front-loaded and the constraint and prerequisite following in priority order. 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?

For a two-parameter write tool with no annotations and no output schema, the description covers action, side effect, scope limits and prerequisite. It is slightly thin on site_id semantics and on what a caller gets back, but is otherwise sufficient to invoke 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 only 50%: sitemap_url is documented in the schema (including its default), while site_id is undocumented in both places. The description's 'URL of an existing file' loosely reinforces sitemap_url but adds nothing about site_id, so it does not compensate for the coverage gap.

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

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

States a specific verb+resource ('Ask Google to recrawl a sitemap') and draws a sharp scope boundary ('submits the URL of an existing file and nothing more'). It does not name the obvious sibling List_Sitemaps or otherwise position itself against the 30+ read-only tools, so it falls short of full sibling differentiation.

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

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

Gives a clear triggering condition ('because it is new or has changed') and a prerequisite ('publish the updated file yourself first'). No alternatives or when-not-to-use guidance are offered, so it stops 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?

With no annotations, the description carries the full behavioral burden and does well: it discloses the returned ratio and diagnosis, the threshold values that trigger each diagnosis, and the crucial caveat that normal attribution/consent/redirect differences produce 10-20% mismatch. It omits prerequisites such as required data-source connections or failure behavior when one source is missing.

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 comparison, then thresholds, then the normalization caveat. Every sentence earns its place and each adds distinct decision-relevant information despite the length.

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

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

With no output schema, the description must explain the return value and does: ratio plus a categorical diagnosis, with the thresholds that map numbers to labels. For a 2-parameter read tool this is complete enough for an agent to call and interpret 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 50%: days is documented in the schema (with min 1, max 480 and default 28), but site_id has no description in either the schema or the description. The description adds no parameter meaning, though site_id is a self-evident identifier used across sibling tools, 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: sanity-checking agreement between Search Console and GA4 organic traffic. It names the exact comparison (GSC clicks vs GA4 organic sessions) and what it returns (ratio plus diagnosis), which clearly distinguishes it from siblings like Search_Analytics or Site_Analytics.

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

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

Gives strong interpretive guidance: thresholds (under 0.5 = tracking_gap, over 1.5 = over_counting, else healthy) and explicitly says a 10-20% mismatch is normal so only extremes should be flagged. It does not name when to prefer an alternative sibling tool or state prerequisites (e.g. both GSC and GA4 must be connected), so it stops short of explicit when/when-not routing.

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