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

Annotations already declare readOnly=true, idempotent=true, destructive=false, openWorld=true, so 'read-only' in the description is largely redundant. It does add two useful constraints beyond the annotations: all reports must target the same property, and the batch is capped at 1-5 reports. Nothing is said about partial failures, per-report errors, or latency in a batch 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?

A single front-loaded sentence with zero filler. The cardinality bound and same-property constraint arrive before anything else, and nothing is repeated.

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 schema is rich and an output schema exists, so return values and parameter formats need no prose. However, for a batch executor the description omits behavior an agent would want before committing: whether reports execute in parallel, what happens if one report fails, and whether quota cost is summed across the batch.

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

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

Schema description coverage is 100%, so both propertyId and the reports array (including nested GA4-native objects) are already documented in the schema. The description adds nothing about parameter syntax or the native GA4 JSON shapes; it only restates the array size bound that maxItems already enforces. 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 (Run) plus resource (GA4 pivot reports) with clear scope: 1-5 independent reports, same property, one Data API batch request. The 'batch' + 'pivot' combination implicitly separates it from ga4_run_pivot_report (single) and ga4_batch_run_reports (non-pivot batch), but no sibling is named 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 rather than stated: the '1-5 ... same property ... one batch' framing tells an agent this is the multi-report variant, but there is no explicit 'use this instead of X when Y' guidance or any exclusion. An agent must infer the choice against ga4_run_pivot_report and ga4_batch_run_reports.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and openWorld, so the safety profile is covered. The description adds that reports are 'independent' (no chaining between them) and that they share one official API batch call, but says nothing about partial-failure behavior, quota cost, or return shape.

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 short sentence, front-loaded with the verb and the key constraint. Every clause (1-5, independent, read-only, same property, one batch request) carries information.

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

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

With an output schema, full annotation coverage, and rich parameter descriptions, the definition supplies the essential framing. The main remaining gap is what happens when one report in the batch fails, which is material for a batch tool.

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

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

Schema description coverage is 100% and the nested report object is well documented, including native GA4 JSON payloads and date format hints. The description only reinforces the maxItems=5 bound and that propertyId applies across all reports, so it adds little 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 (Run), resource (GA4 Core reports), and scope (1-5 reports for a single property in one batch request). The batch framing implicitly separates it from ga4_run_report, but no sibling is named, so an agent must infer the single-vs-batch distinction.

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 '1-5' and 'one batch request' wording implies when to prefer this over the single-report sibling, but there is no explicit when-to-use, when-not, or named alternative. Usage is left to inference from the 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 readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description's one added signal is that the answer comes from the 'official GA4 Data API' (an authoritative server-side check rather than local validation), but it says nothing about quota cost, failure modes, or what an incompatible result looks like.

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 no redundant restatement of the title. Efficient, though terse enough that it forgoes any opportunity to add routing context.

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?

Output schema exists, so return-value explanation is not needed, and the schema documents all six parameters. However, with nested filter objects and a compatibilityFilter that materially changes the result, the description leaves an agent without guidance on intended workflow or on how it differs from ga4_validate_query.

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

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

Schema description coverage is 100%, including the maxItems caps, numeric/properties/{id} ID format, and the compatibilityFilter enum, so the schema does the heavy lifting. The description adds no parameter-level meaning beyond what is already structured, which is the baseline case.

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

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

States a specific verb and resource ('Ask the official GA4 Data API which dimensions and metrics are compatible') with clear scope: a pre-flight compatibility check on a proposed report selection. It is distinguishable from report-running siblings, though the overlap with ga4_validate_query is left implicit.

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

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

The phrase 'proposed Core report selection' implies this is used before running a report, but no explicit when-to-use / when-not-to-use guidance or named alternative (e.g. ga4_validate_query) is given. Usage must be inferred from the prepositional phrase.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description usefully discloses the underlying data sources and a fallback behavior, which adds context beyond annotations. It does not cover authentication needs, rate limits, or what the diagnostics include.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately concise, though it could be slightly more structured by separating purpose from source details.

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

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

The tool has annotations, an output schema, and complete parameter descriptions, so the description need not explain return values or every parameter. However, it remains thin on when to use this diagnostic tool versus its audience-related siblings, which is relevant context for a seven-parameter diagnostics endpoint.

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 seven parameters are documented in the input schema. The description does not add parameter-specific meaning beyond saying the tool reads from several audience-related sources. Baseline 3 is appropriate when the schema already carries parameter semantics.

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

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

The description states a specific read operation and resource: audience diagnostics. It also identifies the three data sources (Admin API, recurring audience lists, report fallback), which helps distinguish it from general reporting tools. It does not explicitly differentiate it from the closely related audience export diagnostics 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?

The description gives no explicit guidance about when to use this tool versus alternatives such as ga4_get_audience_export_diagnostics or ga4_list_audience_exports. Usage is only implied by the word 'diagnostics' and the listed sources, with no when-not or prerequisite guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered; the description mostly restates read-only. It does add one useful behavioral note: that a row sample is optional and that 'state counts' are returned, but says nothing about permissions, quota cost, or what the diagnostics actually reveal beyond listing.

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, front-loaded sentences with no filler; the core action is stated first and the optional sampling capability second. Nothing is redundant or bloated.

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

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

An output schema exists and annotations plus a fully documented schema carry most of the load. But for a diagnostics tool in a crowded GA4 diagnostics family with overlapping list/query siblings, the description omits the one thing an agent most needs: how this differs from ga4_list_audience_exports, ga4_query_audience_export, and ga4_get_audience_diagnostics.

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 every parameter is already documented in the schema, including includeRowSample, includePersonalIdentifiers, and audienceExportName. The description's phrase 'optionally samples rows from an existing export' loosely maps to includeRowSample/audienceExportName but adds no syntax or semantics beyond the schema, so baseline 3 applies.

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

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

The description names a concrete verb set (lists, counts, samples) for the Audience Export resource, so the tool's own purpose is understandable. However, it does not distinguish itself from siblings that appear to do the same things: ga4_list_audience_exports (listing) and ga4_query_audience_export (row sampling). An agent reading only this text cannot tell why it should pick this tool over those two.

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 exclusion of alternatives, despite heavy apparent overlap with ga4_list_audience_exports, ga4_query_audience_export, and ga4_get_audience_diagnostics. The reader is left to infer selection criteria from nothing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered without help from the description. The description adds diagnostic scope (it reports excluded events and dataset location) but says nothing about behavior when no export link exists, whether it queries the BigQuery dataset directly, or latency implications of an open-world 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 front-loaded sentence with the detection action first and the diagnostic facets second; no filler, no restatement of the tool 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 rich annotations, an output schema, and fully documented parameters, the definition covers enough for correct invocation. The remaining gap is behavioral edge cases — what the agent sees when no export link is configured — but that is partly mitigated by the output schema.

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

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

Schema description coverage is 100%: both propertyId (numeric GA4 property ID) and includeDataStreams (include stream summaries to compare against exported streams) are documented in the schema. The description adds no parameter-level semantics beyond that, so baseline 3 applies.

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

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

The description pairs a specific verb ("Detect... and diagnose") with a precise resource (GA4 BigQuery export) and enumerates the facets it inspects: export modes, stream coverage, excluded events, and dataset location. That scope naturally separates it from sibling diagnostics tools such as ga4_get_ecommerce_diagnostics or ga4_get_server_side_tagging_diagnostics, though it never names a sibling explicitly.

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

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

The purpose implies when to call it — you want to know whether a BigQuery export link exists and what it covers — but there is no explicit when-to-use statement, no stated prerequisites (e.g., admin/OAuth scope), and no guidance on alternatives if the agent just wants raw report data. Usage is inferable, not 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 this as a safe, idempotent read operation, so the description does not need to cover safety. It adds the useful scoping detail that these are custom channel groups, but it does not mention pagination, return limits, or whether default/system channel groups are excluded.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for a simple read-only listing 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?

Given the rich annotations, complete input schema, and existing output schema, the description is largely sufficient for correct invocation. The only meaningful omission is usage routing against siblings, which is minor for a simple, scoped listing 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?

There is only one parameter, and schema coverage is 100%, so the schema already explains propertyId fully. The description adds no additional parameter semantics, which is appropriate given the schema already does that work.

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

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

The description names a specific verb and resource: it lists custom channel groups for a GA4 property. This is clear and distinguishable from most reporting siblings, though it does not explicitly contrast with closely related tools like ga4_get_custom_definitions.

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 explicit when-to-use guidance, prerequisites, or alternative tools. It implies usage by naming the resource, but an agent gets no help deciding between this and related custom-definition or configuration tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description's only added behavioral claim, 'read-only fallback', is consistent but redundant; it says nothing about what metadata is fetched, latency, or completeness of the inventory.

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 the resource description front-loaded and the qualifier second. Nothing is padded or repeated from the title.

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

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

With an output schema present and a fully documented single parameter, the description covers what the tool returns at a high level. The only unresolved gap is the unexplained 'fallback' framing, which should identify the primary tool it backs up.

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

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

There is a single parameter with 100% schema description coverage ('GA4 property ID (numeric, e.g., 123456789)'), so the schema carries the full burden. The description adds no meaning about propertyId beyond what the schema states, which is the expected baseline at this coverage level.

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: lists custom dimensions and custom metrics from GA4 Data API metadata. The scope is clear enough to distinguish it from report-running siblings, but it never names or contrasts the closest relative, ga4_get_metadata, leaving the boundary implicit.

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

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

The phrase 'Read-only fallback for custom definition inventory' implies a usage condition, but it doesn't say what it is a fallback to or when an agent should prefer it over ga4_get_metadata or ga4_get_property_configuration. The agent must infer the selection 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so 'Read-only' in the description is partly redundant. What the description does add is the subject matter of the diagnosis and the date-range scoping, but it says nothing about what the diagnostics report (pass/fail checks, missing-event lists, coverage percentages) — the actual behavioral value an agent would need.

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 packs verb, resource, scope, and time dimension with no filler. It is tightly written, though the terseness leaves no room for the one clarifying clause (what the diagnostics actually surface) that would justify a top score.

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 parameter documentation is complete. However, for a diagnostics tool whose whole value is telling the agent what is wrong or missing, the description omits the nature of the findings and any guidance on interpreting or acting on them, leaving a meaningful gap.

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

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

Schema coverage is 100%, so all five parameters — including the datePreset enum and limit bounds — are already fully documented in the schema. The description only echoes the date-range concept and adds no syntax, precedence rules (datePreset vs. startDate/endDate), or format detail beyond the schema. Baseline 3 applies.

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

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

Names a specific resource ('ecommerce coverage diagnostics') and the scope it inspects: core ecommerce events, revenue metrics, and item-level reporting over a date range. This separates it from the generic reporting siblings (ga4_run_report, ga4_run_pivot_report) by domain, though it never explicitly names a sibling 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 only implied: an agent can infer this is for validating that ecommerce tracking data is present and usable before trusting ecommerce reports. There is no explicit 'use this when' clause, no prerequisites, and no guidance on when the other diagnostics tools (audience, BigQuery export, server-side tagging) should be preferred instead.

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

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

Annotations already declare the tool as read-only, idempotent, open-world, and non-destructive. The description adds useful behavioral context by calling the inventory 'best-effort' and noting Data API limitations for raw parameters, which signals that results may be incomplete or constrained.

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 two short sentences with no wasted language. The core purpose is front-loaded, and the limitation note follows efficiently.

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

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

The tool has an output schema and strong annotations, so the description need not explain return values or safety behavior. It covers purpose and a key caveat, though it could more explicitly clarify when this inventory is preferable to metadata or report tools.

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

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

Schema description coverage is 100%, so propertyId, date fields, eventNames, and limit are already documented in the input schema. The description does not add parameter-specific syntax or semantics beyond the schema, which matches the baseline of 3 when the schema does the heavy lifting.

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

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

The description identifies the specific resource as an event parameter inventory sourced from GA4 metadata and event reports. It is clear enough to understand the tool's general purpose, but it does not explicitly differentiate this tool from siblings such as ga4_get_metadata or ga4_run_report.

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 guidance on when to use this tool versus alternatives, nor when not to use it. The phrase 'event parameter inventory' implies a use case, but no sibling tools or selection conditions 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?

Annotations already cover readOnly, idempotent, destructive and openWorld, so the safety profile is fully declared. The description adds one genuinely useful trait beyond that — 'best-effort' counts, warning that results may be approximate or incomplete — but it never explains why counts are best-effort (sampling, thresholding, cardinality) or whether the flag list is exhaustive.

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

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

Two tight sentences that are front-loaded with the verb and resource; the qualifier 'metadata-aware' and the return note both earn their place. Slightly jargon-heavy phrasing but no filler.

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

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

An output schema exists, so return shape needn't be described, and the input schema is fully documented. What is missing is the concrete framing an agent needs: how this differs from a generic ga4_run_report keyed on key events, and what 'best-effort' means operationally.

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

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

Schema description coverage is 100% and the schema documents all five parameters, including the datePreset enum and the interaction with explicit start/end dates. The description adds nothing about parameters, which is acceptable at full coverage but is the baseline score, not a value-add.

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 ('Inventory') and resource ('GA4 key events/conversions'), plus the underlying mechanism (metadata-aware Data API reports). It is clear what the tool returns, though it never names the sibling it competes with (e.g., ga4_run_report with the keyEvents metric), so an agent must infer the differentiation 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 explicit when-to-use or when-not guidance and no named alternative. The description implies a use case (listing key events/conversions) but leaves the agent to work out why it would pick this over ga4_run_report or ga4_get_event_parameters from the 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, idempotentHint, and destructiveHint=false, so the safety profile is fully covered without description help. The description adds only the 'complete list' framing (results are exhaustive for the property) and nothing about scope limits, caching, or property-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?

Two short sentences, front-loaded with the action and resource, then the use case. There is minor redundancy in the second sentence but no wasted text; slightly more structure would be needed for a 5.

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

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

An output schema exists, so return-value detail is unnecessary, and rich annotations cover the behavior profile. The only meaningful gap is that an agent cannot tell from this text whether to prefer it over ga4_get_custom_definitions for custom-dimension discovery.

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

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

With a single parameter at 100% schema description coverage (including a numeric format example), the schema carries the burden entirely and the baseline of 3 is met. The description reinforces the property scoping ('for a specific GA4 property'), adding slight value over 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 ('complete list of dimensions and metrics') scoped to a GA4 property, which is concrete enough to act on. It stops short of distinguishing itself from the sibling ga4_get_custom_definitions, whose territory ('custom dimensions/metrics') it also claims, creating mild overlap ambiguity.

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

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

The second sentence gives an implied use case (discovering custom dimensions/metrics), which suggests calling this before building report queries. However there is no explicit when-to-use/when-not-to-use guidance and no routing to ga4_get_custom_definitions or ga4_get_event_parameters, which cover adjacent discovery needs.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered and the description does not contradict it. The description adds that the settings are 'singleton' Admin surfaces, hinting they are individual config objects rather than lists, but it says nothing about permission requirements, whether unrequested settings cost extra calls, or how missing/unsupported settings are surfaced. Adequate but thin beyond what annotations 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?

A single sentence, front-loaded with the core read action and followed by the enumerated optional surfaces. Every clause carries information; nothing is repeated from the schema or 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?

An output schema exists, annotations cover the safety profile, and there are only two parameters, so the description needn't explain return values. It is nearly complete; the only real gap is the default/no-settings behavior and any permission caveat for Admin settings, which an agent would need before relying on 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 both propertyId and settings are already documented, and the baseline is 3. The description restates the settings enum in human-readable terms and frames them as 'singleton', which is mild added meaning, but it never states the behavior when settings is left at its default empty array (presumably property details only) or whether requesting multiple settings is batched into one call.

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

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

States a specific verb (read) and resource (GA4 property details), then enumerates the exact Admin surfaces it can return: attribution, retention, Google Signals, reporting identity, and user-provided-data settings. That enumeration separates it from the broad sibling ga4_list_admin_resources and from ga4_list_properties without requiring the agent 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?

The phrase 'plus selected ... settings' implies that the settings array is an opt-in extra on top of base property details, which is a usable usage hint. But there is no explicit when-to-use, when-not-to-use, or named alternative (e.g., vs ga4_list_admin_resources or ga4_get_metadata), so the agent must infer the routing.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds genuinely non-obvious behavior: a real quota-token cost is incurred even though no report runs, which an agent cannot infer from any structured field. It stops short of describing failure behavior when quota is exhausted, keeping it at 4.

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

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

Two sentences, front-loaded with the action and resource, and the second sentence carries only the two facts that change agent behavior (no report is run, but a token is charged). 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 and annotations are rich, so return values and safety need no explanation. With a single fully documented parameter, the description covers what's needed to call it correctly; only the quota-exhaustion error path is left unstated.

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

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

Only one parameter exists and the schema documents it fully at 100% coverage ('Numeric GA4 property ID or properties/{id}'). The description adds no syntax or format detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Read the current GA4 Data API property quota snapshot') and pins the source endpoint (v1alpha). The second sentence explicitly separates it from the report-running siblings ('This does not run a report'), so an agent can distinguish it from ga4_run_report 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?

The 'does not run a report' clause implies the usage context (quota inspection rather than data retrieval), which is helpful. But it never states when to reach for this versus alternatives such as ga4_health_check or ga4_list_properties, and gives no prerequisites or exclusions beyond the negative 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds one genuine behavioral fact beyond that: results are 'best-effort', i.e. may be partial or incomplete. Beyond that clause it says nothing about call cost, failure modes, or how many API requests the diagnostics trigger.

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 read-only scoping first and the data sources after; every clause carries information and there is no filler or repetition of the title.

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

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

An output schema exists and the schema documents all three parameters, so the description does not need to explain returns. It is still thin for a broad diagnostics tool: it omits what checks are performed, what a negative finding means, and why an agent would pick this over the other diagnostics siblings.

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

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

Schema description coverage is 100%, so propertyId, includeRules, and includeSettings are already fully documented, and the baseline of 3 applies. The mention of 'event rules' and 'stream settings' loosely maps to the two boolean toggles but adds no syntax, defaults, or trade-off guidance 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 and resource: read-only diagnostics for server-side tagging, naming the inspected surfaces (data streams, Measurement Protocol secrets, event rules, stream settings). This clearly separates it from siblings like ga4_get_ecommerce_diagnostics or ga4_get_bigquery_export_diagnostics. It stops short of saying what a 'diagnostic' actually reports, which keeps it from 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?

Usage is only implied by the tool name and the domain it names; nothing tells an agent when to prefer this over the other *_diagnostics siblings or what prerequisite property state is needed. The 'best-effort' qualifier hints at reliability limits but is not framed as a usage 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 readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description adds real value beyond them by naming the verification targets and noting it works 'without exposing OAuth tokens', which tells the agent this is a safe credential probe. It stops short of saying what a failing check returns, though an output schema exists.

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

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

Two tight sentences with the read-only nature and the tool's identity front-loaded, then the concrete checks. No filler or 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?

With an output schema present and rich annotations, the description needn't explain return values. It covers what is verified and the credential-safety angle; the only gap is what the agent should do when a check fails.

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

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

Schema description coverage is 100% and there is only one optional parameter, so the schema already carries the semantics. The description gestures at it ('metadata/property access') but adds no new detail such as what omitting propertyId means for the scope of checks.

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 ('Read-only GA4 health check') and enumerates what it verifies (credentials, accessible properties, metadata/property access). It is clearly a preflight diagnostic rather than a reporting tool, though it never names a sibling to contrast with (e.g. ga4_list_properties or ga4_get_metadata).

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

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

Usage is only implied: the 'health check' framing suggests running it before real queries, and the optional propertyId hints at a targeted verification pass. There is no explicit when-to-use, when-not-to-use, or pointer to alternatives like ga4_check_compatibility if the check fails.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description still adds real value beyond them: "accessible to the authenticated user" discloses the auth-scoping rule and "auto-paginated" tells the agent it will not have to loop manually — a behavior the single pageSize parameter alone would not convey.

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

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

A single front-loaded sentence with no filler. Scope, access constraint and pagination behavior are packed into one clause sequence, and nothing is redundant with the title.

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

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

An output schema exists, so return values need not be described, and the description covers scope, auth and pagination for a zero-required-parameter list tool. The only meaningful omission is its position in the workflow relative to ga4_list_admin_resources and ga4_list_properties.

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

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

Schema coverage is 100% and there is only one optional parameter (pageSize), which the schema fully documents including default 200 and max 200. The description's "auto-paginated" implies the agent need not manage paging, but it adds no syntax or semantics beyond the schema, so the baseline 3 applies.

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

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

Specific verb+resource: "List raw GA4 Analytics Admin accounts" scoped to "accessible to the authenticated user". This distinguishes it from report-running siblings like ga4_run_report, though it does not explicitly contrast with the adjacent ga4_list_admin_resources or ga4_list_properties, which an agent could plausibly confuse it with.

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

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

Usage is only implied: an agent can infer this is the discovery step for account IDs, but nothing states when to pick it over ga4_list_admin_resources or ga4_list_properties, and no prerequisites or follow-up steps are given. Adequate but with a clear routing gap in a crowded list/get sibling set.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so 'read-only mode' is largely redundant restatement. The genuinely additive context is the 'allowlisted' constraint — only a fixed set of collections is reachable — which tells the agent requests outside the enum will fail. Pagination behavior and the personal-identifier redaction default are left to 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?

A single front-loaded sentence that puts the verb, resource and read-only constraint first, then enumerates scope. The long trailing list earns its place by pre-signalling which collections exist, though it is dense enough to be slightly hard to scan.

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

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

With rich annotations, a 100%-documented schema, and an output schema, the description only needs to establish scope and safety, which it does. The absence of routing guidance versus the specialized getter siblings is the one meaningful gap for a tool in this crowded family.

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 explains propertyId formats, the collection enum, pageSize limits, and the includePersonalIdentifiers redaction default. The description's enumeration of collections loosely mirrors the enum but adds no operational detail beyond it, so baseline 3 applies.

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

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

States a specific verb ('List') and resource ('allowlisted GA4 Admin collection') and enumerates the covered collections, so an agent knows exactly what domain it touches. It stops short of naming the overlapping siblings (ga4_get_custom_definitions, ga4_get_key_events, ga4_get_channel_groups), so the boundary between this generic lister and those specialized getters is not explicitly drawn.

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?

'read-only mode' and 'allowlisted' imply this is a safe read path for administrative config, giving implied usage context. However there is no explicit guidance on when to pick this generic lister over the sibling-specific getters that read the same collections, nor any prerequisite or exclusion statements.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered structurally. The description's only added context is the 'without creating new exports' reassurance, which reinforces but does not extend the annotation set; it says nothing about rate limits, permissions, or snapshot freshness.

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

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

A single sentence with the resource identified up front and the negative constraint placed at the end where it disambiguates rather than buries the main point. No filler.

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

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

With an output schema present, return values need no explanation, and annotations carry the safety profile. The remaining minor gap is that an agent must consult the schema to learn about pagination and the includeRecurring toggle, which the description could have surfaced.

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

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

Schema description coverage is 100%, with pageSize, propertyId, and includeRecurring each documented including defaults and bounds. The description contributes no additional parameter meaning, so the baseline 3 applies.

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

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

States a specific verb (list) and specific resources (GA4 Audience Export snapshots and Recurring Audience Lists), which is far more informative than the title's restatement. The 'without creating new exports' clause implicitly distinguishes it from the creation/query path used by siblings like ga4_query_audience_export, though it never names a sibling outright.

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 reader infers this is the read/inspect path and that export creation belongs elsewhere. There is no explicit 'use X when you want to create an export' routing to ga4_query_audience_export, and no prerequisite or pagination-follow-up guidance in the description itself.

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

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

Annotations already declare readOnly, idempotent, open-world, non-destructive, so the safety profile carries no burden here. The description adds the credential-scoping behavior, which is genuinely useful, but says nothing about pagination, rate limits, or what happens with insufficient permissions — minor but real gaps for a discovery call.

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

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

Two short sentences, zero waste, with the scope constraint front-loaded before the return-value note.

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 listing return fields is not strictly required, and with annotations covering safety the definition is close to sufficient. The remaining gap is whether results are paginated or complete in one call, plus how property listing relates to account listing.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly says nothing spurious about inputs.

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

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

States a specific verb and resource ("List all GA4 properties") plus the scoping qualifier "accessible with the current credentials." That distinguishes it from reporting siblings, but it never names the nearest neighbors (ga4_list_accounts, ga4_list_admin_resources), so the boundary with those is left implicit.

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

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

The phrase "accessible with the current credentials" implies this is a discovery/enumeration call, but there is no explicit when-to-use, no prerequisite statement, and no mention of when to prefer ga4_list_accounts or ga4_list_admin_resources instead.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds a meaningful privacy trait not in annotations: identifiers are redacted by default and only returned via explicit opt-in. It could say more about output handling or rate limits, but the core behavioral addition is present.

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

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

Two short sentences with zero waste. The core purpose is front-loaded, followed immediately by the important privacy caveat.

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

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

With rich annotations, an output schema, and fully documented parameters, the description covers purpose and the key privacy behavior. The only meaningful gap is the absence of explicit routing guidance to or from sibling tools such as ga4_list_audience_exports.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters. The description only restates the redaction default for includePersonalIdentifiers, adding no new parameter semantics beyond what the schema already states.

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

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

The description states a specific verb (Query) and resource (rows from an existing GA4 Audience Export), which clearly separates it from listing exports or running reports. However, it does not explicitly name or contrast with sibling tools like ga4_list_audience_exports or ga4_get_audience_export_diagnostics.

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 'existing GA4 Audience Export' implies a prerequisite, and the required audienceExportName parameter's schema description points to list_audience_exports. But the description itself offers no explicit when-to-use guidance, exclusions, or alternative tool comparisons.

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

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

Annotations already cover the safety profile (readOnly, idempotent, openWorld, non-destructive), so the description only needs to add beyond that — and it does, disclosing that this targets an alpha endpoint and that failures degrade to read-only step counts with the limitation made explicit. That degradation contract is meaningful and not fully conveyed by annotations 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?

A single front-loaded sentence with no filler; the endpoint identity comes first and the two behavioral qualifiers follow. Nothing in it is 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?

The rich schema and output schema mean return values and parameters need not be restated, but for a 13-parameter tool sitting beside a near-twin funnel sibling, the description leaves the crucial routing decision unexplained and never clarifies when the fallback path actually triggers. Adequate, with clear gaps.

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

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

With 100% schema description coverage every one of the 13 parameters is already documented in the schema, so the baseline is 3. The description echoes breakdown and next-action support, but adds no syntax, bounds (10 steps, 250k rows), or interaction rules 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 and resource ("Run the GA4 Data API v1alpha runFunnelReport endpoint") and adds the notable modifiers breakdown/next-action and step-count fallback. It does not, however, distinguish itself from the sibling ga4_run_funnel_recipe, which an agent would reasonably confuse 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?

There is no explicit when-to-use or when-not guidance, and the most relevant alternative (ga4_run_funnel_recipe, plus ga4_run_report for non-funnel reporting) is never named. The fallback sentence describes runtime behavior rather than selection criteria, so the agent must infer routing.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds real behavioral context beyond them: the tool fans out to one GA4 report per step (implying cost proportional to step count) and returns only 'simple step counts' rather than full breakdowns.

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 read-only nature plus the return shape come early. It is efficient, though arguably too terse for a six-parameter tool with a nested steps array.

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 parameter documentation is complete in the schema. However, the description leaves important gaps for a funnel tool: whether step counts are sequential (with drop-off) or independent per-step totals, and the quota cost of one report per step.

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

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

Schema description coverage is 100% and every field, including the nested step object and enums, is documented in the schema. The description reinforces that steps key off eventName/pagePath but adds no format, default, or constraint detail beyond what the schema already states. 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 ('Run') and resource ('configurable funnel recipe') and explains the mechanism: one GA4 report per eventName/pagePath step. It does not name the obvious sibling ga4_run_advanced_funnel_report, so an agent must infer the distinction from 'simple step counts' 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 explicit when-to-use guidance, no exclusions, and no mention of alternatives such as ga4_run_advanced_funnel_report or ga4_run_report. The only hint is the word 'recipe', leaving the agent to guess when this funnel variant 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds meaningful behavior beyond annotations: quota state is returned, multiple date ranges are supported, and there is a 250,000-cell cap with a mandatory explicit limit per pivot. It does not explain pagination/offset behavior or error conditions, but it does more than repeat 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?

The description is two sentences, front-loads the core purpose, and uses the remaining space for the most important constraint (explicit limit per pivot). No sentence is wasted, and it is appropriately sized for a complex tool whose schema carries detailed parameter information.

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

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

With an output schema, rich annotations, and full schema description coverage, the description supplies the essential calling context: it is a read-only pivot report, quota state is available, and every pivot needs an explicit limit. The main remaining gap is routing guidance versus batch pivot reports and plain reports, but an agent has enough information to invoke 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 description coverage is 100% and the nested report object is fully documented, including required pivot limit, date range formats, and filter expression types. The description reinforces the explicit-limit requirement and mentions multiple date ranges, but adds little syntax or semantic detail beyond what the schema already provides. 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?

The description names a specific verb and resource: 'Run a read-only GA4 Data API pivot report.' The word 'pivot' distinguishes it from the plain ga4_run_report sibling, but it does not explicitly contrast itself with ga4_batch_run_pivot_reports or other report variants, leaving some sibling differentiation to inference.

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

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

Usage is implied by 'pivot report' — an agent can infer this is the tool for pivoted output rather than a flat report. However, the description never states when to choose this over ga4_run_report, ga4_batch_run_pivot_reports, or ga4_validate_query, nor does it specify exclusions or prerequisites beyond the limit requirement.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so 'read-only' is redundant. The second sentence adds genuine value by warning that only a limited subset of dimensions and metrics is supported, but it does not say how to discover that subset or what error behavior to expect.

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 operation stated first and the realtime limitation second. It is efficient, though for a 9-parameter tool with nested objects it is close to under-specified rather than merely tight.

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, but for a tool with nested FilterExpression/OrderBy JSON and minute-range semantics the description gives no pointer to compatibility checking or metadata lookup for valid dimension/metric names. Adequate to identify the tool, thin for calling it correctly on first try.

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

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

Schema description coverage is 100%, so every parameter is already documented, including minuteRanges, limit, and the native JSON filter expressions. The description adds only a general constraint about which dimensions/metrics are valid, not per-parameter meaning, 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?

The description names a specific verb and resource ('Run a read-only GA4 Data API realtime report'), and the word 'realtime' implicitly separates it from the sibling ga4_run_report. It does not explicitly state the sibling distinction, 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?

Use for realtime data is implied by the name and first sentence, but there is no explicit when-to-use/when-not guidance and no mention of ga4_run_report, ga4_check_compatibility, or ga4_get_metadata as alternatives for standard or validated queries.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and open-world, so the safety profile is covered. The description adds the per-request field caps and notes auto-pagination, but 'intelligent query planning' is unexplained and nothing is said about quota/rate-limit behavior even though a quota-snapshot sibling exists.

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

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

Three short sentences, front-loaded with the core action and followed by constraints and the field-discovery pointer. Only 'with intelligent query planning' is vague filler; everything else 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, rich annotations, and 100% parameter coverage, the description only needs to add the field limits and the discovery path for valid metric/dimension keys — both of which it does. An agent has enough to construct a valid call.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds a constraint absent from the schema: a maximum of 9 dimensions and 10 metrics per request (the schema sets no maxItems on dimensions). That is genuine meaning beyond the structured fields.

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 ('Run a GA4 analytics report') and adds scope details (52 metrics, 63 dimensions, auto-pagination). It does not, however, distinguish itself from close siblings like ga4_run_realtime_report, ga4_run_pivot_report, or ga4_batch_run_reports, leaving the agent to infer which report runner to pick.

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 a prerequisite ('Use ga4://metrics and ga4://dimensions resources for available fields') and a hard cap ('Max 9 dimensions + 10 metrics'), which are useful usage constraints. It never says when to choose this over the realtime, pivot, funnel, or batch variants, so selection 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?

Annotations already establish that this is read-only, idempotent, non-destructive, and open-world. The description adds useful behavioral detail by stating exactly what is validated: max limits, ecommerce rules, and dimension compatibility. It does not describe failure behavior, but the output schema covers return values.

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

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

The definition is two short sentences and front-loads the action and timing. Every phrase adds useful information: the action, the pre-execution timing, and the specific validation checks.

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 validation tool with full schema coverage, rich annotations, and an output schema, the description is largely complete. The main remaining gap is that it does not clarify how this tool relates to the similar ga4_check_compatibility sibling.

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

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

Schema coverage is 100%, so the schema already documents the two parameters. The description adds meaningful constraints beyond the schema, notably the 9-dimension and 10-metric maximums, which are not encoded in the input schema. It still does not explain metric/dimension key formats, but that is partly covered by the schema descriptions.

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

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

The description uses a specific verb and resource: validate a metric/dimension combination. It also names the checks performed, including limits, ecommerce rules, and dimension compatibility. However, it does not explicitly differentiate itself from the sibling ga4_check_compatibility, which appears closely related.

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 'BEFORE executing' clearly places this tool in a pre-flight validation role. That gives the agent usable context for when to call it. It does not, however, name alternatives such as ga4_check_compatibility or state when not to use it.

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