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

Annotations cover the safety profile (readOnlyHint, openWorldHint), so the bar is lower, and the description adds real behavioral value beyond them: it promises partial-failure reporting ('plus the properties that failed and why'), which tells the agent to expect per-property error entries rather than an all-or-nothing failure. It does not mention rate limits or cost of fanning out across many properties.

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

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

Front-loads the purpose in the first line and keeps the returns list tight. The 'Args:' block is minimal and not wasteful, though it slightly duplicates the one parameter already named in prose.

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

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

An output schema exists, so explaining return fields is arguably redundant, and the description wisely focuses its extra words on failure reporting. However, with 0% schema coverage the undocumented date range parameters leave the agent guessing about the time window, which is material for a metrics tool.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, but it only addresses property_ids (giving an example ID format). The date_start and date_end parameters — including their defaults of '7daysAgo'/'today' and accepted date syntax — are never mentioned, leaving a real gap.

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

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

States a specific capability: batched summary metrics across multiple GA4 properties, enumerating the metrics returned (sessions, active users, conversions, bounce rate, avg session duration). This implicitly differentiates it from single-property siblings like run_report or get_property, though it never names those alternatives explicitly.

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

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

The phrase 'in one call' and the plural 'several GA4 properties' imply this is the batch option, but there is no explicit when-to-use/when-not statement or comparison to run_report/conversions_summary. Usage must be inferred from the metric list and plural framing.

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

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

The description states that with apply=True the tool 'creates only the missing pieces' (GA4 property, stream, key events, dimensions), which is a write operation, while annotations declare readOnlyHint=true. An agent trusting the annotation could invoke apply=True believing the call is non-mutating. The description's own behavioral content is rich, but it directly contradicts the structured safety hint.

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 plan-vs-apply distinction, which is the single most important fact, then covers safety, returns, and follow-ups before a clean Args list. It is longer than average, but the length is justified by an 8-parameter dual-mode tool; a little tightening around the repeated 'missing pieces / skipping what exists' phrasing is possible.

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

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

For an open-world, potentially-mutating bootstrap tool this covers the mode switch, confirmation requirement, server prerequisite (--enable-writes), idempotency, and manual follow-up steps. An output schema exists, so it correctly does not need to narrate return structure beyond mentioning the G- measurement ID and TXT token.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it does: every one of the eight args is documented with meaning, format, or example (site_url URL form, account_id cross-reference to list_account_summaries, IANA time_zone, ISO 4217 currency_code, key_events example, custom_dimensions, and apply's default semantics).

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

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

States a specific verb and resource ('Plan, and optionally apply, the full measurement setup of a website') and immediately scopes its domain (GA4 property/stream, key events, custom dimensions, Search Console property). This is clearly distinguishable from sibling read-only lookups like list_properties or list_data_streams.

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: default apply=False produces a plan that must be shown to the user for confirmation before apply=True. It also names the alternatives for the parts it does not handle (sc_verify_site_dns, sc_submit_sitemap) and explains why they stay manual, so the agent knows exactly where this tool's job ends.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description contributes one real behavioral detail, that results are restricted to active key events, but says nothing about aggregation semantics, row limits, or how zero-conversion events are handled.

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

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

A single short sentence with no filler, and the key information (metrics plus grouping dimension) is front-loaded. It is terse to the point of under-specification, but not padded.

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

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

An output schema exists, so return values need no explanation, but with three undocumented parameters at 0% coverage and no usage routing against six closely related siblings, the definition is not complete enough to invoke confidently.

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 description never mentions property_id, date_start, or date_end. The date defaults ('7daysAgo' to 'today') and required property scope are left entirely for the agent to infer, so the description 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 resource (conversions and total users per event name) and scopes it to active key events, which is more informative than a bare restatement of the name. It does not, however, differentiate itself from the sibling events_summary, so an agent cannot tell the two apart from the text 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?

There is no guidance on when to use this versus run_report, events_summary, or top_pages, and no exclusions or prerequisites are given. The only implicit cue is 'active key events', which is a scope statement rather than usage direction.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered by structured fields. The description adds the audit framing as context but discloses nothing about result shape, ordering, pagination, or how the limit interacts with counts. Adequate but thin against an already-covered safety profile.

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

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

Two short sentences, front-loaded with the core action ('count of every event that fired') followed by the practical follow-up step. No filler or 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?

An output schema exists, so return values need not be explained, and the alternative-tool routing is helpful. However, with 0% parameter coverage and no mention of the date window or limit semantics, the definition leaves meaningful operational gaps for calling the tool correctly.

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

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

Schema description coverage is 0% and the description never mentions any of the four parameters. It is silent on property_id, limit (default 50), and the date_start/date_end defaults ('7daysAgo'/'today'), leaving the agent to infer date-window semantics and whether limit truncates results — a real gap for a counting tool.

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 action and resource: counting every event that fired, framed as an audit of measurement coverage. It distinguishes itself from the query/report siblings by being a summary-count rather than a detailed breakdown, though it does not explicitly disambiguate against conversions_summary or web_vitals_summary.

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 explicit usage context: compare with list_key_events to find key events that never fire. That names a concrete alternative and the condition that motivates it. It stops short of saying when NOT to use this tool or what other siblings to prefer for deeper analysis.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that the response includes the measurement ID for web streams, which is useful read-shape context, but says nothing about auth, errors, or scoping. With annotations carrying the load, a 3 is appropriate.

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

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

A single tight sentence with the core action front-loaded and no filler. It is efficient, though it errs toward under-specification rather than being a model of concise completeness.

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

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

An output schema exists, so return-value details are not required, and the safety annotations cover the read profile. However, with two undocumented required parameters at 0% coverage and no usage context, the definition is only barely sufficient for an agent to call it correctly.

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

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

Schema description coverage is 0% for both required parameters, so the description must compensate and largely does not. 'One data stream' vaguely gestures at stream_id, but property_id is entirely unexplained and no format or ID-source guidance is offered for either.

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

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

States a specific verb+resource ('Get one data stream') and adds a useful detail about the measurement ID of a web stream. The singular 'one' implicitly contrasts with the sibling list_data_streams, but it does not explicitly name an alternative, so it falls just short of a 5.

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

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

The description gives no when-to-use context, no prerequisites, and no explicit alternative. An agent could infer 'retrieve a single stream by ID' vs. list_data_streams, but nothing in the text states the selection condition.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety and reach profile is covered. The description adds the returned field set, which is mild extra context, but says nothing about auth requirements, error behavior, or what happens with an invalid/foreign property_id.

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

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

A single front-loaded sentence naming the verb, resource, and output fields. No filler and nothing buried.

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

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

An output schema exists, so return-value detail is unnecessary, and annotations cover the read-only/open-world profile. For a single-param read, the description is nearly complete, with only the property_id sourcing detail 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 0%, so the description would normally need to compensate, but there is only one self-evident parameter (property_id) and its purpose is clear from the name. Still, the description supplies no format, source, or example for the identifier, so it adds nothing beyond the schema.

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

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

States a specific verb (Get) and resource (GA4 property) and enumerates the settings returned (time zone, currency, industry, type). The word 'full settings' implicitly contrasts with the sibling list_properties, but it never names that sibling, so differentiation is left to inference.

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

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

No indication of when to call this versus list_properties or get_data_stream, no prerequisites, and no exclusions. The agent must infer usage purely from the tool name and the surrounding sibling list.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that results are scoped to accessible accounts and include property summaries, but says nothing about volume, pagination, or ordering of a potentially large account list.

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

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

Two short sentences, zero filler, with the action and scope front-loaded and the usage hint second. Every sentence earns its place.

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

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

With an output schema present, return-value detail is not required, and annotations cover the read-only nature. The description supplies the entry-point role and the IDs it yields, which is what an agent needs; only edge cases like empty access or result size are 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?

The tool takes zero parameters, so there is nothing for the description to clarify; baseline for a no-parameter tool applies. The description correctly implies a full unfiltered enumeration of accessible accounts.

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 GA4 account') plus the payload ('with a summary of its properties'), scoping it to accounts the caller can access. This distinguishes it from list_properties/get_property siblings, which operate on properties rather than the account roll-up.

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?

'Start here to find the account_id and property_id the other tools need' gives explicit entry-point guidance and states why an agent would call it before other tools. It does not name a specific alternative to avoid, but the routing intent is unambiguous.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered without the description. The description adds the useful detail that each dimension's scope is returned, but no pagination, auth, or rate-limit behavior. With annotations carrying the safety burden, a 3 is appropriate.

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

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

A single front-loaded sentence that names the resource and the extra detail (scope) with zero wasted words.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. However, the required property_id is left completely undefined and there is no usage context, leaving gaps for an agent to call it correctly.

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

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

Schema description coverage is 0% and the single property_id parameter is undocumented in the schema. The description only implies a GA4 property is targeted, giving no format, source, or example for the required property_id, 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 (list) and resource (custom dimensions declared on a GA4 property), plus the notable detail that scope is included. It is clearly distinguishable from siblings like list_properties or list_data_streams, though it does not explicitly 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?

There is no indication of when to reach for this tool versus the many other list_* siblings, nor any prerequisites (e.g., that a property_id must come from list_properties first). Usage must be inferred from the name alone.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds useful content about what web streams contain (measurement ID, default URI), but says nothing about pagination, ordering, or what happens for a property with no streams.

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

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

Two short sentences, front-loaded with the core action and scope; the second sentence adds non-redundant detail about web stream contents. No filler.

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

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

The output schema carries the return-value burden, and annotations cover the read-only/no-side-effect profile, so the description is nearly sufficient for a simple one-param list tool. The remaining gap is the undocumented property_id format, which neither schema nor description resolves.

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 schema provides no description for property_id (0% coverage), and the description only implies it through 'of a GA4 property'. It does not state the expected ID format (numeric vs. 'properties/123'), which is the main thing an agent needs for this single required 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?

States a specific verb and resource ('List the data streams') scoped to a GA4 property, and enumerates the stream types (web, iOS, Android). It is distinguishable from the singular sibling get_data_stream, though it never names that sibling explicitly.

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

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

There is no when-to-use or when-not-to-use guidance. It never tells the agent to prefer get_data_stream for a single stream, nor when this list should be called versus list_properties or get_property to discover a property.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing behavioral beyond that: no note on pagination, whether one or many links can be returned per property, or any auth/scope requirements. It is essentially a restatement of purpose, not added behavioral context.

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

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

One front-loaded sentence with zero filler, which is appropriate for a simple list tool. It is perhaps too terse to earn a 5, since no extra clarifying clause is offered.

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

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

The tool is simple (one param, read-only) and an output schema exists so return shape need not be described. However, with the parameter undocumented in both schema and description and no usage context, the definition is only minimally viable.

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%: property_id has no description in the schema. The description implies 'a GA4 property' but never explains the expected identifier format (numeric ID vs. properties/123 path) or that it is required. 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 (List) and resource (links between a GA4 property and Google Ads accounts), so the agent knows exactly what is returned. It does not explicitly contrast itself with siblings like list_properties or list_data_streams, but the Google Ads scope is distinctive enough to tell apart.

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

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

No when-to-use guidance, no prerequisites, no mention of alternatives. The agent must infer that this is the tool to call when it needs ads-link data for a known property_id.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds no behavioral context beyond that – no pagination behavior, no mention that property_id is required, no scoping or auth notes. It is essentially a one-line restatement of the resource being read.

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

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

A single tight sentence, front-loaded with the verb and resource, that also carries the useful rename note. 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?

An output schema exists, so return values needn't be described, and this is a simple one-parameter read tool. Still, with annotations covering only safety and the parameter undocumented, the definition is merely adequate rather than complete.

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

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

Schema description coverage is 0% for the single required parameter. The phrase 'on a GA4 property' weakly indicates what property_id refers to, but gives no format or example (e.g. 'properties/123456'), so it fails to compensate for the schema 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?

Specific verb+resource ('List the key events ... declared on a GA4 property') and it clarifies the renamed concept ('formerly conversions'), which helps an agent disambiguate from the conversions_summary sibling. It stops short of explicitly naming which sibling it is not, so it doesn't reach a 5.

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

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

There is no when-to-use / when-not-to-use guidance and no alternatives named, despite siblings like conversions_summary and events_summary that an agent could plausibly confuse with this configuration-listing tool. Usage is only weakly implied by the word 'declared'.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuine behavioral context beyond annotations by explaining include_deleted returns soft-deleted (trashed) properties with a 35-day retention window, which materially affects how an agent interprets results.

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

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

Front-loaded one-line summary followed by a compact Args block. No wasted sentences, and the format is standard and easy to parse, though the docstring-style Args section is slightly heavier than prose for two simple parameters.

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

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

An output schema exists, so return-value details are not required in the description. Purpose, both parameters, and the trashed-property semantics are covered. The only gap is routing guidance relative to sibling tools, which is minor given the clear verb+resource.

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

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

Schema coverage is 0%, so the description carries the burden and does so adequately: it documents the accepted account_id formats ('123456789' or 'accounts/123456789') and the meaning of include_deleted. Both parameters are covered, though no default value is restated (schema already provides it).

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

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

The description states a specific verb and resource ('List the GA4 properties under an account'), which is clear and actionable. It doesn't explicitly differentiate from siblings like get_property (single property) or list_account_summaries (different resource), but the 'under an account' scope distinguishes it reasonably well.

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: enumerate properties for a given account. There is no explicit when-to-use guidance or named alternative (e.g., get_property for a single property, list_account_summaries to find account IDs). An agent must infer the routing from context.

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?

Goes well beyond the readOnlyHint/openWorldHint annotations by disclosing the 30-90s latency, the anonymous-quota rate-limit behavior (HTTP 429), the required PAGESPEED_API_KEY, and the conditional nature of CrUX data (only returned when Chrome has sufficient real-user traffic). These are exactly the operational facts an agent needs before scheduling a 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?

Front-loaded with the one-line purpose, then budget/auth caveats, then Args and Returns in tight blocks – no filler sentences. The Returns block partially duplicates the declared output schema, but it earns some of its space by noting the CrUX field data is conditional on real-user traffic.

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

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

Covers everything needed to call this correctly: the target resource, latency, auth/quota caveat, all three parameter semantics with defaults and enums, and a summary of what comes back. With an output schema present it need not spell out the return shape, and it still gives a useful high-level view.

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

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

Schema coverage is 0%, so the description must carry the parameters, and it does: url as an absolute public URL with a concrete example, strategy with its 'mobile' default and 'desktop' option, and categories as a subset of four named values defaulting to all four. This supplies the enum values, defaults, and format constraints that the bare schema omits.

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

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

States a specific verb (Run audit) and resource (PageSpeed Insights on a public URL) and unpacks what the audit composes: 'Lighthouse lab test + CrUX field data.' The lab+field composition implicitly distinguishes it from the sibling psi_field_data_only without the agent needing to open 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 clear context for use: a public URL, a 30-90 second runtime, and the prerequisite that a PAGESPEED_API_KEY is needed for regular use because the anonymous quota returns 429s. It stops short of explicitly naming psi_field_data_only as the lighter alternative when the agent only wants field data, so the when-not case 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?

Beyond the readOnly/openWorld annotations, the description adds real behavioral context: the 15-40 second latency expectation, the fact that a Lighthouse pass is still run server-side even though only field data is returned, and the semantics of overall_category including its null case when traffic is too low. Auth and rate limits are not covered, but this is strong added value.

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, with each following sentence adding non-redundant information (latency, category semantics). 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?

An output schema exists, so return values needn't be explained, and safety is covered by annotations. However, the strategy parameter is entirely unaddressed despite 0% schema coverage, and there is no guidance on the relationship to psi_audit, leaving a notable gap for a two-parameter tool with an unenumerated strategy field.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It clarifies that data covers 'a URL and its origin', which adds some scope context, but it never explains the strategy parameter (mobile vs desktop, default mobile) nor the expected url format. The key behavioral parameter is left 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 names a specific resource (CrUX field data) and scope (a URL and its origin), and the lead-in 'Only the CrUX field data' implicitly distinguishes it from sibling psi_audit, which presumably returns full Lighthouse results too. It could be sharper by explicitly contrasting with psi_audit, but an agent can tell what this returns.

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: 'Only the CrUX field data' suggests picking this when you don't want lab/Lighthouse output, but it never states when to choose this over psi_audit or names that sibling. No explicit when/when-not guidance is given.

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

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

readOnlyHint and openWorldHint already cover the safety profile, and the description usefully adds the 30-minute freshness window as a behavioral constraint. It says nothing about the realtime API's tighter quotas, auth requirements, or the non-final/unsampled nature of realtime data, so the added context is modest against the lower annotated baseline.

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

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

The scope statement is front-loaded in a single clean sentence, followed by the use case and a compact Args block. No filler, though the Args section is raw list formatting rather than tight prose.

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

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

An output schema exists, so return values need not be described, and annotations handle safety. Combined with the explicit time window, defaults, and use case, the definition is nearly sufficient — the only gaps are the undiscussed property_id and limit parameters.

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

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

Schema coverage is 0%, so the description must carry parameter meaning, and it does supply real value for metrics and dimensions — defaults ('activeUsers', 'eventName') and valid alternatives that the bare schema (default null) does not reveal. However, the required property_id and the limit parameter receive no explanation at all, leaving half the parameters 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?

States a specific verb and resource with a hard scope boundary: a realtime report covering the last 30 minutes. The 'realtime' framing implicitly separates it from the historical run_report sibling, but it never names that contrast explicitly, so the differentiation is left to inference.

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

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

Gives a concrete triggering scenario ('confirm that a new event fires in production right after a deploy'), which tells an agent when this tool is the right call. It stops short of stating when-not to use it or naming run_report as the alternative for historical data.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered. The description adds practical defaults (limit 25, order_desc True) and date-format flexibility, but says nothing about GA4 quota/rate limits or auth requirements, which is the kind of behavioral context that would add real value here.

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

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

The one-line purpose is front-loaded and the args block is organized per parameter with examples, so it is easy to scan. The two documentation URLs are useful rather than filler, though the block is slightly long.

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 flexible 8-parameter report tool with an output schema, the description covers inputs well and even names the return shape (dimensions, metrics, date range, row_count, rows), which the output schema already carries. The main gap is the absence of routing guidance against its many specialized siblings.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it does so thoroughly: property_id format ('properties/123456789'), metrics/dimensions examples plus schema catalog links, accepted date_start/date_end formats ('YYYY-MM-DD', 'today', 'NdaysAgo'), limit default, and ordering semantics. All eight parameters are meaningfully documented.

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 clear verb+resource ('Run a flexible GA4 report') and the word 'flexible' implies a general-purpose query tool, which distinguishes it in spirit from the preset siblings (top_pages, events_summary, traffic_sources). However, it never names or contrasts any sibling, so the differentiation is left to inference.

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

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

There is no explicit when-to-use or when-not-to-use guidance. It does not tell the agent when to reach for run_report versus the many specialized siblings (run_realtime_report, conversions_summary, web_vitals_summary) or versus list_properties/get_property. The reader must infer usage entirely.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that results include errors and warnings, which is mild behavioral context, but says nothing about pagination, sitemap-index expansion, or permission requirements.

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

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

One front-loaded sentence with the verb and resource first and the result contents trailing; nothing redundant or padded.

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

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

An output schema exists, so return values need not be spelled out, and annotations cover the read-only/open-world profile. For a single-parameter list tool this is nearly complete, with only the site_url format left unaddressed in both description and schema.

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

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

Schema description coverage is 0% and there is only one parameter, site_url, which the schema leaves entirely undocumented. The description implies the parameter is the Search Console property ('for a Search Console site') but does not give the expected format (e.g., https:// prefix vs sc-domain:), so it only partially compensates.

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?

Clear specific verb+resource: 'List the sitemaps submitted for a Search Console site,' augmented with what the results contain ('errors and warnings'). It is distinguishable from sc_list_sites and the GA4 list_* tools by resource, though it never explicitly contrasts itself with any sibling.

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

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

Usage is only implied: an agent can infer this is the tool for enumerating sitemaps of a given Search Console property. There is no statement of when to prefer it over sc_list_sites or other sc_* tools, and no prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds useful return-shape context (siteUrl conventions and the four permissionLevel values), but since an output schema exists this is partly redundant and no pagination or scoping behavior is disclosed.

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 tightly written sentences, front-loaded with the purpose before the field detail. Every sentence carries information and nothing is padded.

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

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

For a zero-parameter list tool with an output schema and annotations covering the safety profile, the description is essentially complete. Only the relationship to the sibling list tools is left 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?

The tool takes zero parameters, which is the baseline-4 case. There is no parameter surface for the description to clarify or omit.

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

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

States a specific verb (List) and resource (Search Console sites you can access), so the agent knows it enumerates accessible properties. It does not, however, explicitly differentiate from the sibling 'list_properties', which could plausibly be confused with this tool.

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

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

No when-to-use guidance and no named alternatives. Usage is only weakly implied by 'sites you can access', and the agent is left to infer whether list_properties or list_account_summaries is the correct entry point.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. Beyond that, the description adds no behavioral context: it does not state that a site_url and date window are mandatory, whether dates are constrained, or how the limit behaves. It mostly restates the metric list, which the output schema already carries.

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

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

A single front-loaded sentence with no filler, and the key resource is named first. It is efficient, though its brevity contributes to the gaps elsewhere rather than being a virtue of careful editing.

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

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

With an output schema present, the metric list need not be restated, yet the description still omits required-parameter expectations, date-range semantics, and sibling differentiation for a crowded Search Console toolset. For a tool with three required inputs, this is too thin.

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

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

Schema description coverage is 0% for all four parameters, so the description carries the full burden and adds essentially nothing about site_url, date_start, date_end, or limit. The only implicit hint is that 'Top pages' implies ordering/truncation, which loosely relates to limit.

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 (top pages in Google Search) and the metrics returned (clicks, impressions, CTR, average position), so an agent understands it is a page-level Search Console performance report. However, it never contrasts itself with close siblings like sc_top_queries, top_pages, or sc_query_breakdown_by_page, leaving the agent to infer the distinction from the name alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternative tools. The agent must guess that this is the page-dimension counterpart to sc_top_queries and how to choose between them.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds no extra behavioral context – nothing about the Search Console data source, date-range expectations, or result ordering – so it neither contradicts nor enriches the annotations.

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

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

Two short sentences, front-loaded with the core question, no filler. The second sentence earns its place as usage context, though the description is arguably under-specified rather than maximally efficient.

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

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

An output schema exists so return values need not be described, and the read-only annotations cover safety. However, with four required parameters and 0% schema coverage, an agent lacks format guidance for dates and URLs, leaving a real gap for a data-query tool.

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

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

Five parameters with 0% schema description coverage, and the description names none of them beyond implying a page. Formats for date_start/date_end, page_url, and the meaning of limit (default 25, per-page query cap) are left entirely undocumented in both schema and prose.

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 ('which search queries bring traffic to one specific page') and scopes it to a single page, which naturally separates it from site-wide siblings like sc_top_queries. It never explicitly names an alternative, so it stops short of a 5 but is unambiguous about what it returns.

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?

'Useful to decide which keywords to strengthen in that page's content' gives a downstream purpose but no when-to-use trigger, prerequisites, or comparison to sibling tools such as sc_page_performance or sc_top_queries. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds genuinely useful operational context: Search Console data lags 2-3 days and limit caps at 25000 rows. Return format is left to the output schema.

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

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

Purpose sentence and per-argument list are front-loaded and waste-free; each line earns its place by encoding a format constraint. The dict-style 'Args:' layout is readable but slightly verbose for a 5-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?

With an output schema present, the description need not explain return values, and it covers all parameters plus the data-freshness caveat. The only real gap is guidance on choosing this tool over its query/page-oriented siblings.

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

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

Schema description coverage is 0%, so the description carries the full burden and does so well: site_url format with the 'sc-domain:' vs URL forms and a pointer to sc_list_sites, date format 'YYYY-MM-DD', limit max 25000, and country as an ISO 3166-1 alpha-3 code with examples ('mex'/'usa'). Every parameter gets concrete format guidance the schema lacks.

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

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

Opens with a specific verb+resource pair ('Top search queries') and enumerates the returned metrics (clicks, impressions, CTR, average position). This clearly distinguishes it from siblings like sc_page_performance and sc_query_breakdown_by_page, though it never names those siblings explicitly.

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

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

Usage is implied by the resource ('queries' vs 'pages') and the required date range, but the description gives no explicit when-to-use/when-not or pointer to an alternative tool. An agent must infer selection from sibling names alone.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds only a metric inventory, which an existing output schema already conveys, and says nothing about auth requirements, quotas, or whether results are sorted/truncated by limit.

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

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

A single tight sentence with the resource front-loaded and zero filler. It is efficient, though it spends its one clause on metrics rather than on the parameters or usage context that are actually missing.

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

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

An output schema exists, so return-value explanations are rightly omitted, and the annotations cover the read-only nature. However, for a four-parameter analytics report with 0% schema coverage, the absence of any date-range or scope guidance leaves an agent guessing how to call it correctly — this is a moderate gap rather than a fatal one.

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

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

Schema description coverage is 0% — none of the four parameters (limit, date_start, date_end, property_id) is documented anywhere. The description mentions sessions and metrics but adds no meaning to any parameter, not even the '7daysAgo'/'today' date defaults or what property_id must reference.

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 (top pages) and the ranking dimension (sessions), plus the metric set returned. This is clearly distinguishable from siblings like traffic_sources or sc_page_performance, but the description never explicitly contrasts itself with those alternatives.

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

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

No when-to-use guidance at all: nothing indicates whether this is the right tool for a page-level traffic breakdown versus run_report or traffic_sources, and no prerequisites (e.g., needing a valid property_id) are mentioned.

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

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

Annotations cover the safety profile (readOnlyHint=true, openWorldHint=true), so the bar is lower. Still, the description says nothing about default behavior beyond what the schema shows, no row-limit behavior, no note that it queries live GA4 data, and the listed metrics duplicate information available in the output schema.

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

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

A single front-loaded sentence with the resource first and the returned metrics last. No filler, no redundancy.

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

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

An output schema exists, so return values needn't be explained, and the safety annotations are adequate. However, with zero parameter documentation and no usage guidance, an agent still lacks enough to invoke this correctly for a 4-parameter reporting tool.

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

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

Schema description coverage is 0% across four parameters, so the description carries the full burden and fails: it never mentions property_id, the date range, the 7-day default, or what limit controls. The phrase 'top' only loosely implies a limit 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?

States a specific resource and scope: top traffic sources broken down by source/medium, with the metrics returned (sessions, active users, conversions). This is clearly distinguishable from siblings like top_pages or conversions_summary, though it never explicitly names those alternatives.

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

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

The description gives no when-to-use guidance, no exclusions, and no mention of how it relates to run_report or the other summary tools. The agent must infer that this is a pre-built report from the name alone.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds a genuinely useful behavioral precondition — the required custom dimensions and event parameters — implying results are empty or unavailable if the site isn't instrumented. It stops short of saying what happens when the prerequisite is unmet or what auth scope is needed.

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

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

Three short sentences, front-loaded with what the tool returns, then prerequisites, then the alternative. No filler and no repetition of the schema.

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

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

An output schema exists, so return values need not be described, and the prerequisite and alternative-tool information is present. The remainder of the gap is the undocumented date-range and property parameters, which the description leaves entirely to the schema.

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

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

Schema description coverage is 0% and the description says nothing about `property_id`, `date_start` or `date_end` semantics (formats, defaults, timezone). The two parameters it does name, `web_vital_metric` and `web_vital_rating`, are GA4 event dimensions, not inputs to this tool, so they add no invocation guidance and risk being mistaken for arguments.

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 (Core Web Vitals) and its exact data source (GA4 events sent by the user's own site), which separates it from the other GA4 report tools and from the PSI siblings. Naming psi_field_data_only as the contrasting tool makes the distinction 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?

Gives an explicit prerequisite (site must send web-vitals events with `web_vital_metric` and `web_vital_rating` registered as event-scoped custom dimensions) and an explicit routing rule: 'For Google's field data use psi_field_data_only instead.' An agent can decide when this tool applies without guessing.

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