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

Annotations already provide readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds 'read-only' which aligns with the annotation but doesn't provide additional behavioral details (e.g., rate limits, execution semantics). Given the strong annotation coverage, the description adds minimal extra value beyond confirming the read-only nature.

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, well-structured sentence that front-loads the core action and scope. Every word contributes to the meaning—there is no redundancy or filler.

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

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

The tool has an output schema (as indicated), so the description does not need to explain return values. The description fully covers the tool's purpose and usage context—batch pivot reports for a single property—with no missing information that would hinder an agent from invoking it correctly.

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

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

Schema description coverage is 100%, with detailed property descriptions for propertyId and reports. The description only restates the '1-5' limit and the 'native GA4' aspect, which are already present in the schema. It adds no new parameter-level semantics, so a baseline of 3 is appropriate.

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

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

The description clearly states the action (run), the resource (GA4 pivot reports), and the specific scope (1-5 independent reports in one batch for the same property). It distinguishes itself from siblings like ga4_run_pivot_report (single) and ga4_batch_run_reports (non-pivot batch) by explicitly mentioning pivot and batch.

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 specifies when to use it: when you need multiple pivot reports for the same property in one request. It implies alternatives (single pivot report, general batch) but does not explicitly state when not to use it or name alternatives. Still, the context is clear enough for an agent to infer the appropriate use case.

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, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful scope context—same property, independence, and one official batch request—but otherwise depends on annotations for the safety profile. It does not disclose details like batch failure semantics or quota behavior.

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

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

A single, front-loaded sentence with no filler. Every element—count, read-only nature, report type, property scope, and batch mechanism—earns its place and supports agent decision-making.

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 strong annotations, 100% parameter schema coverage, and presence of an output schema, the description is largely complete for invocation. It could be marginally stronger by naming ga4_run_report as the single-report alternative, but nothing essential for calling the tool is missing.

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

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

Schema description coverage is 100%, and the schema already documents propertyId and the reports array in detail. The description's phrases 'independent' and 'same property' add modest context but do not meaningfully expand on the parameter semantics beyond what the schema provides.

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

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

The description states a specific action ('Run'), resource ('GA4 Core reports'), scope ('same property'), and batching behavior (1-5 reports in one request). This clearly differentiates it from single-report tools like ga4_run_report and from pivot-based batch tools like ga4_batch_run_pivot_reports.

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 conveys clear usage context: use this when running 1-5 independent read-only Core reports together for one GA4 property. It does not explicitly name alternatives or state when not to use it, but the context is specific enough to guide selection.

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, and this description does not contradict them. The description adds that the check targets the official GA4 Data API, but it does not reveal additional behavioral details such as rate-limit implications or the nature of the compatibility response beyond what the output schema and annotations would 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?

The description is a single clear sentence that states the tool's purpose with no filler or repetition of schema fields. It is front-loaded with the core behavior and outcome.

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 strong annotations, complete parameter schema, and the existence of an output schema, the description is largely complete for the tool's complexity. It could be slightly richer by naming the related validation sibling, but nothing essential for calling it is missing.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including dimensions, metrics, propertyId, filters, and compatibilityFilter. The description adds no extra semantic meaning beyond what the parameter descriptions already provide, placing this at the baseline score.

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 action ('ask the official GA4 Data API') plus a precise outcome: checking which dimensions and metrics are compatible for a proposed Core report selection. It clearly differentiates this from siblings like ga4_run_report or ga4_validate_query by focusing on compatibility, not execution or validation.

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 intended use is implied: use this tool to check whether dimensions and metrics are compatible before running a report. However, it never explicitly states when to prefer this over the closely related ga4_validate_query or other GA4 report validation tools, so usage guidance is adequate but not explicit.

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

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

The annotations already provide readOnly/idempotent/non-destructive hints; the description adds the multi-source behavior and a fallback, which is useful. It does not clarify what 'observed audienceName report fallback' means or how the sources are combined, so disclosure remains partial.

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 compact sentence with no filler and the read-only constraint is front-loaded. The dense 'observed audienceName report fallback' phrase slightly hurts readability but not length.

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

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

For a read-only tool with a full input schema, an output schema, and strong annotations, the description is minimally viable. It is thin on how sources are combined and when to select it, but structured context fills most operational 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?

Schema description coverage is 100%, so params like propertyId, dates, limit, and includeDefinitions are already well documented. The prose description adds no parameter semantics beyond what the schema provides, keeping it at the baseline.

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 a specific resource ('audience') and an action ('read-only diagnostics'), and names the data sources it draws from, which is more informative than just the title. However, it doesn't explicitly contrast with the sibling ga4_get_audience_export_diagnostics, and the phrase 'observed audienceName report fallback' is cryptic.

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 is given. There is no mention of which sibling tools are alternatives, no conditions for choosing this over the other diagnostics tools, and no exclusions. An agent must infer the intended use 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?

The description reiterates the readOnlyHint and adds modest behavioral specifics: it lists state counts and optionally samples rows from an existing export. It doesn't explain side effects, but the annotations already cover read-only, idempotent, and non-destructive behavior, so the description adds context without contradicting them.

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 concise sentences are front-loaded with the read-only diagnostics nature and then the capabilities. There is no filler, no restating of the obvious name, and no redundant detail.

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 a full input schema and an output schema present, the description needs only to orient the agent, which it does. The only real gap is the lack of guidance on when to use this diagnostic versus the similarly named list/query siblings.

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

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

The input schema already documents all six parameters with descriptions (100% coverage), so the description is not responsible for parameter semantics. It mentions 'optionally samples rows' and 'existing export', reinforcing sampleLimit and audienceExportName, but adds no new parameter-level meaning.

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 ('Lists') and identifies a clear resource ('existing audience exports, state counts') with an optional sampling behavior. It distinguishes itself from a generic reporting/query tool through the 'diagnostics' framing, though it doesn't explicitly name sibling tools that overlap.

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

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

No guidance is provided on when to choose this diagnostic over ga4_list_audience_exports or ga4_query_audience_export. The description simply lists capabilities; the agent must infer that diagnostics are for troubleshooting. There are no explicit exclusions or fallback instructions.

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 signal readOnly, idempotent, and non-destructive behavior. The description adds context beyond annotations by specifying exactly what is examined: export modes, stream coverage, excluded events, and dataset location. It does not disclose potential edge cases like empty results, but the output schema likely covers return specifics.

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 dense sentence conveys the tool's purpose and diagnostic scope with no filler. Each listed item adds useful information, and the primary verb 'Detect' is front-loaded.

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

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

With an output schema present, read-only annotations, and a required propertyId documented in the input schema, the description is largely sufficient. It could be slightly more complete by mentioning when to prefer this tool over related diagnostics, but that gap is minor given the tool name and sibling context.

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

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

Both parameters are fully described in the schema (propertyId and includeDataStreams), so the schema carries the semantic burden. The description does not add parameter-specific guidance, only implicitly connects 'stream coverage' to includeDataStreams. Baseline 3 is appropriate given 100% schema description coverage.

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

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

The description uses a specific verb ('Detect'/'diagnose') with a concrete resource (GA4 BigQuery export links) and enumerates diagnostic dimensions: export modes, stream coverage, excluded events, and dataset location. This clearly distinguishes it from sibling diagnostic tools like ga4_get_audience_export_diagnostics or ga4_get_ecommerce_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 description makes the tool's domain clear: BigQuery export diagnostics. An agent can infer when to choose this over related diagnostic tools, though it does not explicitly name alternatives or state when not to use it. This is clear context but lacks explicit 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, idempotentHint=true, openWorldHint=true, and destructiveHint=false, and the description's 'List' aligns with these. The description adds no extra behavioral detail such as pagination, authorization requirements, or scope limitations, but because the annotations already cover the safety profile, this is acceptable.

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 one clean, front-loaded sentence with no filler. It states the verb and object immediately and earns every word.

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

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

For a simple read-only tool with one parameter, full output schema, and strong annotations, the definition is largely sufficient to call it correctly. A brief pointer to related lookup tools would improve it, but that gap is already captured under usage_guidelines.

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 is already fully documented in the input schema. The description's 'for a GA4 property' adds no information beyond the schema, so it does not exceed the baseline for a fully described single-parameter 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 names a specific resource ('custom channel groups'), a clear verb ('List'), and a scope ('defined for a GA4 property'). It does not explicitly differentiate from siblings like ga4_get_custom_definitions or ga4_get_metadata, so the agent must infer the boundary.

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 guidance is provided on when to use this tool versus alternatives such as ga4_get_custom_definitions or ga4_get_property_configuration. The only implicit usage context is the phrase 'defined for a GA4 property,' which is not enough to route an agent deciding between similar lookup 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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is established. The description adds mild context by clarifying that results come from GA4 Data API metadata and that the tool serves as a fallback, but it does not disclose limitations, pagination, or error behavior beyond what annotations and output schema likely cover.

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

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

Two short sentences with no redundant wording. The core listing behavior is front-loaded, and the fallback qualifier is placed second without detracting from clarity.

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?

This is a low-complexity, one-parameter read-only tool with a rich annotation set and an output schema. The description adequately covers what the tool does and its fallback role; no critical calling information is missing.

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

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

Schema description coverage is 100% and the sole parameter propertyId is already fully documented in the schema. The description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('List') and a concrete resource ('custom dimensions and custom metrics exposed by GA4 Data API metadata'). This clearly distinguishes it from broader metadata tools like ga4_get_metadata and from analytics/diagnostic siblings.

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

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

The 'Read-only fallback for custom definition inventory' phrase implies a use case but does not explicitly state when to prefer this tool over alternatives such as ga4_get_metadata, nor does it describe when not to use it. Some context is present, but it is not actionable guidance.

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

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

The description labels the tool 'Read-only', which matches the annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false), but this adds no new behavioral information beyond the annotations. It provides useful context about the diagnostic scope (events, revenue, item-level reporting) but does not disclose additional behavioral traits such as rate limits or data 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?

The description is a single sentence that front-loads the read-only nature and clearly specifies the diagnostic subject and time scope. It contains no filler or redundant phrasing and is highly scannable.

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 presence of an output schema and rich annotations, the description sufficiently conveys the purpose and scope for an agent to decide to invoke it. It could be more explicit about what 'coverage diagnostics' means in terms of output, but the output schema likely covers return structure. Minor gap: no guidance on how this relates to other reporting 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 the input schema fully documents all five parameters including defaults and date formats. The description adds only the general notion of 'over a date range', which is already captured by startDate, endDate, and datePreset. No additional parameter-level meaning is provided.

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 clearly identifies the tool as 'Read-only ecommerce coverage diagnostics' and specifies the covered areas: core ecommerce events, revenue metrics, and item-level reporting over a date range. This distinguishes it from sibling diagnostics like audience, BigQuery, or server-side tagging 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 description implies usage for ecommerce coverage diagnostics but provides no explicit guidance on when to prefer this over ga4_run_report, ga4_run_pivot_report, or other diagnostics tools. No alternatives or exclusion conditions are mentioned, so the agent must infer from the name and description.

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, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds meaningful context beyond those annotations by noting the result is best-effort, combines metadata with event reports, and acknowledges Data API limitations for raw parameters. This gives the agent important expectations about completeness and reliability.

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 with no filler. It front-loads the core function ('best-effort event parameter inventory'), then adds the key caveat about Data API limitations. Every phrase 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 a 100%-covered input schema, an output schema, and annotations that fully describe safety, the description adds the missing caveat about effort and limitations. It is sufficient for an agent to decide whether to invoke this tool. It could name sibling tools for clearer routing, but the current context is adequate given the rich structured data.

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 input schema fully documents all six parameters, their types, defaults, and constraints. The description itself adds no parameter-level semantics. Baseline 3 is appropriate because the schema carries the burden and the description need not repeat 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 clearly communicates that the tool produces an inventory of event parameters from GA4 metadata and event reports, and that it documents limitations of the Data API for raw parameters. It is distinct from sibling tools that handle audits, reporting, or custom definitions, though it relies on the phrase 'best-effort inventory' rather than an explicit verb like 'retrieves' or 'lists.' Overall the resource and scope are specific enough to be useful.

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

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

The description implies usage: when an agent needs a best-effort inventory of event parameters, this is the tool. However, it does not name alternatives or explicitly state when not to use it, such as when needing custom definitions (ga4_get_custom_definitions) or a standard report (ga4_run_report). The usage context is clear but not fully articulated.

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 read-only, idempotent, and non-destructive profile. The description adds 'metadata-aware Data API reports' and 'best-effort' as behavioral context, which hints at approximate results and a metadata-based approach, but it doesn't explain exactly why results are best-effort or what 'metadata-aware' means operationally.

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-load the action and resource, then add the key return-value detail. There is no filler or redundant restatement of the tool name, and the description earns its length.

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

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

For a read-only inventory tool with thorough parameter documentation, an output schema, and safety annotations, the description covers the core purpose and return type. The only notable gap is the vague 'metadata-aware' phrasing, but it doesn't block correct invocation.

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

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

Schema description coverage is 100%, so all five parameters are already documented with defaults, bounds, formats, and enum choices. The description adds no new parameter-level detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific action ('Inventory') on a specific resource ('GA4 key events/conversions') and notes the return content ('best-effort event names and counts'). It is clear and distinguishable from siblings like ga4_get_event_parameters or ga4_run_report, though it doesn't explicitly name 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 clearly implies when to use it: when you need an inventory of GA4 key events/conversions with counts. It does not provide explicit 'do not use when' guidance or name alternatives, but the intended context is unmissable and the 'best-effort' qualifier signals a limitation.

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 description does not need to cover side effects. It adds only moderate context beyond that, such as the 'complete list' scope, but does not mention response limits, pagination, or property prerequisites.

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

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

Two short sentences with the main action and scope front-loaded, followed by a concrete use case. There is no redundant or filler language.

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

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

For a simple metadata-listing tool with one fully documented parameter, an output schema, and complete safety annotations, the description is largely sufficient. It loses a point because the boundary with ga4_get_custom_definitions is unclear, which could lead an agent to select the wrong sibling tool.

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

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

The input schema fully describes propertyId with type and an example, so the description need not repeat parameter details. It adds no significant semantic nuance beyond 'specific GA4 property', so the baseline of 3 is appropriate.

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

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

States a specific verb ('Get'), resource ('complete list of dimensions and metrics'), and target ('specific GA4 property'). It is clear and actionable, but it does not explicitly contrast with ga4_get_custom_definitions or the report tools, which also deal with dimensions/metrics, so sibling differentiation is only partial.

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

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

Provides a practical use case ('Useful for discovering custom dimensions/metrics'), which implies a discovery context. However, it gives no explicit when-to-use vs. alternatives, especially ga4_get_custom_definitions, and no exclusions or conditions for choosing another tool.

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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is clear without description help. The description's 'Read' verb reinforces non-mutation and the phrase 'selected singleton Admin settings' adds some context about the data source, but no additional behavioral traits such as auth needs, rate limits, or empty-result behavior are disclosed. Given strong annotation coverage, this is adequate but not additive.

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 sentence with no filler; the action ('Read') and subject ('GA4 property details plus...') are front-loaded. It earns its place, though the phrase 'selected' is somewhat vague without the parameter 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?

The tool is simple with one required string parameter and one optional array with enum, has a full input schema, rich annotations, and an output schema, so the description does not need to detail outputs. The one-line description plus structured data is sufficient for an agent to invoke it. A minor gap is not explaining what happens when 'settings' is omitted, but the schema default [] covers this.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description lists the same five settings values that appear in the schema enum, adding little new information; the term 'singleton Admin settings' is the only added semantic. This falls at the baseline 3 because the schema carries the 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 uses the verb 'Read' and identifies a specific resource: GA4 property details plus selected singleton Admin settings (attribution, retention, Google Signals, reporting identity, or user-provided-data settings). The explicit enumeration of settings distinguishes this from broader tools like ga4_list_properties or ga4_list_admin_resources, though it does not name a sibling directly.

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 guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, state when not to use it, or point to related tools for listing properties or admin resources. The intended use is only implied by the tool name and read-only nature.

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 read-only/idempotent/non-destructive, and the description adds meaningful behavior beyond that: it targets the v1alpha endpoint, does not execute a report, and still consumes one property-quota token. The quota-charging detail is exactly the non-obvious behavior a caller needs to know.

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 focused sentences front-load the core action and then add the one cost caveat that matters. No redundant phrases.

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

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

For a one-parameter read tool with a full output schema and safe annotations, the description covers action, endpoint, and the only non-obvious call consequence. Nothing essential is missing.

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

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

Schema coverage is 100%, so the single required propertyId is already documented, and the description adds no additional parameter meaning beyond confirming the endpoint context. 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 opens with a specific verb ('Read'), a precise resource ('current GA4 Data API property quota snapshot'), and the endpoint ('official v1alpha endpoint'). It also distinguishes itself from report-generation siblings by stating it does not run a 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?

The description implies a monitoring use case and warns against treating it as a report, but it never explicitly states when to choose this tool over siblings or what conditions should trigger its use. The cost note is useful context but not direct routing guidance.

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

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

The annotations already declare readOnlyHint and idempotentHint, and the description adds useful behavioral context with 'best-effort' and 'read-only,' signaling that results may be partial or non-authoritative. It also names the exact sources checked, which goes beyond the structured annotations. No contradiction with annotations 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?

A single, front-loaded sentence that conveys scope, read-only behavior, and data sources with no filler. Every element contributes to understanding what the tool does.

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

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

The description covers the tool's purpose and data sources, and with an output schema and strong annotations, it does not need to explain return values. The main gap is the lack of usage differentiation from siblings, but as a standalone diagnostic description it is reasonably 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 100%, so the parameters are already well-documented. The description adds marginal value by mapping 'event rules' and 'stream settings' to includeRules and includeSettings, but it does not reveal beyond the schema. 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 clearly identifies the resource (server-side tagging diagnostics) and names the specific data sources it draws from, which distinguishes it from sibling diagnostic tools like ga4_get_ecommerce_diagnostics. However, it uses a noun phrase rather than an explicit verb like 'Gets' or 'Returns,' so the action is only implied.

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 guidance is provided on when to use this tool versus alternatives such as other diagnostic tools or reporting tools. There are no exclusions, prerequisites, or context hints to help an agent select among siblings.

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

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

Annotations already establish readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is well covered. The description adds valuable context by explicitly stating that it verifies credentials, accessible properties, and metadata access without exposing OAuth tokens, which is not present in 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?

The description is a single dense sentence that front-loads the read-only nature and core checks. The OAuth token note is a valuable addition, and every phrase earns its place with no 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?

For a tool with one optional string parameter, rich annotations, and an output schema, the description provides the essential behavioral scope. It does not explain when to run the health check relative to sibling tools, but that gap is accounted for in usage guidelines, and the schema is sufficient for invoking 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?

The input schema fully documents the single optional propertyId parameter with 100% description coverage. The description only indirectly references metadata/property access, which may relate to propertyId, but it adds no new parameter-level semantics beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool's purpose: it is a read-only GA4 health check that verifies configured credentials, accessible properties, and metadata/property access while avoiding exposure of OAuth tokens. This is more specific than the title alone, though it does not explicitly differentiate itself from sibling diagnostic tools.

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 states what the tool does but gives no guidance on when to use it versus the many sibling diagnostic or reporting tools. There is no mention of prerequisites, sequencing, or exclusions, so an agent must infer usage from the name and 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false). The description adds genuine behavioral context beyond annotations: auto-pagination behavior ('auto-paginated') and the raw/unprocessed nature of the data returned, plus the user-scoping constraint. No contradiction with annotations.

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

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

A single sentence packs the verb, resource, scope, safety posture, and pagination behavior into one front-loaded clause with parenthetical extras. There is zero filler and every element earns its place.

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

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

For a low-complexity tool with one optional, fully documented parameteraint — and an output schema that relieves the description of explaining return values — the description is complete. An agent knows what it returns, for whom, and how pagination behaves.

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% — the pageSize parameter is fully documented with default, bounds, and pagination guidance, so the description needs to add little. 'Auto-paginated' weakly reinforces the schema's pagination note but adds no new parameter-level meaning; the baseline 3 applies.

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

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

The description names a specific verb ('List'), a precise resource ('raw GA4 Analytics Admin accounts'), and a scope ('accessible to the authenticated user'). It clearly differentiates from siblings like ga4_list_properties and ga4_list_admin_resources by specifying the account level, and 'raw' further disambiguates from processed/report-style tools.

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

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

The description implies when to use the tool — as a read-only listing of accounts for the current user — and names no prerequisites beyond authentication. However, it never explicitly contrasts with any sibling list tool (e.g., ga4_list_properties, ga4_list_admin_resources) or states when not to use it, so routing among the many list-style siblings is left to inference.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description repeats 'read-only mode' but adds a useful nuance: only 'allowlisted' collections are supported. It does not disclose pagination, but the pageSize schema description covers that, so this is acceptable given the strong annotation coverage.

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

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

The description is a single sentence with a front-loaded action ('List...') followed by a colon-led list of collections. It is efficient and structured, though the list overlaps heavily with the schema enum, making it slightly redundant. Still, it earns its place by giving an at-a-glance scope.

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 a complete schema, a present output schema, and safety annotations, the description gives enough for an agent to invoke the tool correctly. The only notable gap is the lack of differentiation from specialized sibling getters, which is more of a usage-guidance issue than an invocation-correctness issue.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including the enum for 'collection' and the access-bindings-only note for includePersonalIdentifiers. The description's enumeration of resource types maps to enum values but adds only a human-readable summary, not new semantic detail. 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 states a specific verb ('List') and a specific resource ('allowlisted GA4 Admin collection'), and then enumerates the exact collection types it covers. This clearly differentiates it from the reporting/diagnostic sibling tools and tells an agent what it operates on.

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 guidance is given about when to use this tool versus specialized siblings such as ga4_get_custom_definitions, ga4_get_key_events, or ga4_get_channel_groups. The description implies a general admin-listing role but leaves the agent to infer the relationship between this generic list and the more targeted getters.

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 the description carries a lower burden. It adds a small amount of context by emphasizing 'existing' snapshots and recurring lists, but it doesn't cover pagination behavior or which export states are returned.

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 sentence that leads with the action and resource and ends with a clear non-creation caveat. Every clause earns its place; no repeated or redundant content.

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

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

For a simple read-only list endpoint with a full output schema and fully documented parameters, the description is largely complete. The only notable gap is the absence of guidance on pagination or the relationship to querying an export, though the schema already explains pagination follow-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?

Schema description coverage is 100%, so the schema fully documents propertyId, pageSize, and includeRecurring. The description's phrase 'Recurring Audience Lists' faintly echoes includeRecurring but adds no parameter-level detail beyond the schema, matching the baseline.

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?

Description has a specific verb ('List'), a specific resource ('GA4 Audience Export snapshots and Recurring Audience Lists'), and explicitly excludes creation ('without creating new exports'). This makes the tool's role obvious and separates it from mutation or diagnostic siblings.

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

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

The description implies usage for retrieving existing exports/lists, but it doesn't name a sibling alternative (e.g., querying or creating exports) or state when to prefer this tool over ga4_query_audience_export. 'Without creating new exports' is a useful non-mutation cue but not explicit routing guidance.

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

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

Annotations already cover readOnlyHint, idempotentHint, and non-destructive behavior, so the bar is lower. The description adds useful auth-scope context ('accessible with the current credentials') and specifies the returned fields, but it does not mention pagination, ordering, or any rate-limit behavior. It does not contradict 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 action and scope, followed by a useful summary of returned fields. There is no redundant or filler language.

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 parameterless, read-only list tool with rich annotations and an output schema, the description is complete. An agent knows what it lists, under what credential scope, and what the primary returned fields are. No additional context is needed to select or invoke 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?

The input schema has zero parameters, so the baseline is 4. The description correctly implies no arguments are needed and does not introduce any misleading parameter expectations.

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 ('List') and resource ('GA4 properties') and adds a scoping qualifier ('accessible with the current credentials'), clearly distinguishing it from tools like ga4_list_accounts and ga4_list_admin_resources. It tells the agent exactly what object is being returned without 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 description makes the use case clear: call this when you need the set of GA4 properties available to the current credentials. It does not explicitly name sibling tools to exclude, but the resource types are distinct enough that an agent can infer when to use this tool.

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

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

With readOnlyHint and idempotentHint already declared in annotations, the description adds valuable behavioral context: user/device identifiers are redacted by default and require explicit opt-in. This is meaningful beyond what annotations alone convey and does not contradict them.

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 with no filler: the first states the core operation, and the second captures an important caveat. Every sentence earns its place and the critical opt-in detail is front-loaded.

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

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

For a simple read-only query tool with fully documented parameters, an output schema, and safety annotations, the description plus schema covers everything an agent needs to call it correctly. Pagination and resource-name guidance are already provided in 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 100%, so the baseline is 3. The description adds extra meaning by clarifying the default redaction behavior and explicit opt-in requirement, which directly informs how includePersonalIdentifiers should be interpreted.

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 ('Query rows from an existing GA4 Audience Export'), clearly indicating what the tool operates on. It is distinct enough from siblings like list_audience_exports because it targets export rows rather than the export list, though it does not explicitly compare itself to 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 establishes a clear usage context: use this when needing to query rows from an already-created GA4 Audience Export. It lacks explicit exclusions or named alternatives, so it stops short of a 5, but the context 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 establish readOnly, idempotent, and non-destructive behaviorikuha. The description adds meaningful behavioral context: it calls out the v1alpha endpoint (implying experimental status) and discloses the fallback to read-only step counts when the advanced funnel is unavailable. This goes beyond what annotations state without contradicting them.

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 packs the endpoint, key optional features, and the fallback behavior. It is front-loaded and contains no filler. Every clause earns its place.

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

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

With 13 parameters and an output schema, the description plus the schema cover most operational detail. However, the description lacks any usage-context guidance (e.g., when to choose this over the simpler funnel recipe) and doesn't hint at pagination or rate-limit handling beyond the schema's limit parameter. It is adequate but not fully complete for a complex 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?

Parameter descriptions in the schema are complete (100% coverage) and already explain each field. The description only highlights 'optional breakdown/next-action', which maps to breakdownDimension and nextActionDimension, adding minimal interpretive value. This matches the baseline for full schema coverage.

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

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

The description names a specific endpoint ('GA4 Data API v1alpha runFunnelReport') and action ('Run'), plus distinctive features (breakdown/next-action, fallback to step counts). It is clear about what the tool does, though it does not explicitly contrast with the sibling ga4_run_funnel_recipe, 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?

The description gives no guidance on when to prefer this tool over alternatives like ga4_run_report or ga4_run_funnel_recipe, nor any exclusions based on property capabilities or date-range constraints. The only hint is the fallback behavior, which is about runtime behavior rather than selection criteria.

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. The description reinforces safety with 'read-only' and adds useful behavioral context: one report per step and simple step counts. It does not go further into rate limits, ordering semantics, or failure behavior, but the annotation coverage lowers the burden.

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 one sentence and front-loads the core purpose ('Run a read-only configurable funnel recipe'). It is economical, though 'read-only' is partially redundant with the 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?

The description plus a fully documented schema covers the essential call semantics for a moderate-complexity tool, and an output schema exists for return-value structure. However, it does not clarify what 'funnel recipe' means beyond sequential steps, nor does it warn about potential limitations relative to advanced funnel analysis.

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

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

Schema description coverage is 100%, so parameters like propertyId, steps, matchType, metric, startDate, endDate, and datePreset are already documented in the input schema. The description does not add meaningful parameter-level detail beyond echoing 'eventName/pagePath step', so the schema carries the weight, which aligns with the baseline.

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 ('Run') and a specific resource ('configurable funnel recipe'), and adds a meaningful implementation detail: it uses one GA4 report per eventName/pagePath step and returns simple step counts. This makes its purpose reasonably distinct from generic ga4_run_report and hints at a lighter-weight alternative to ga4_run_advanced_funnel_report, though it does not explicitly name a 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?

There is no explicit guidance on when to choose this tool over alternatives such as ga4_run_advanced_funnel_report, ga4_run_report, or ga4_validate_query. The phrase 'simple step counts' implies a basic funnel use case, but no when-to-use or when-not-to-use conditions are 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, idempotentHint, and non-destructive behavior, so the lower bar applies. The description adds real behavioral detail: native filters/ordering, quota state, support for multiple date ranges, the 250,000-cell ceiling, and the required limit. There is no contradiction with 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?

One dense sentence front-loads the verb and resource, then lists the most important capabilities and constraints in order. Every clause adds information; there is no filler or repetition of annotation values.

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 nested report schema is complex, but it is fully described and an output schema exists, so the description does not need to enumerate every field. It covers the key behavioral constraints an agent needs to invoke the tool correctly. A small gap is the lack of an explicit pointer to alternatives such as batch pivot reporting or cohort behavior, though those are discoverable from the schema and sibling list.

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 reported at 100%, so the baseline is 3. The description reinforces the 250,000-cell maximum and the explicit-limit requirement, but these are already encoded in the schema's max/min constraints. It does not add meaningfully new parameter-level 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 an explicit verb and resource: 'Run a read-only GA4 Data API pivot report.' The mention of 'pivot report' clearly distinguishes it from siblings like ga4_run_report and ga4_run_realtime_report, while 'native filters, ordering, quota state, multiple date ranges' sharpens the scope. No 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?

Provides clear context for when to use the tool: any pivot-reporting need against GA4 Data API, with native filters and multiple date ranges. It also gives a crucial usage rule—'Every pivot requires an explicit limit'—which directly guides invocation. It stops short of naming alternatives or exclusions, such as when to prefer ga4_batch_run_pivot_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 establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate safety. It adds one useful behavioral constraint: realtime supports only a limited subset of dimensions and metrics. Beyond that, it does not describe timeout windows, validation behavior, or quota implications, but the annotation coverage lowers the burden.

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 short and front-loaded: the first sentence states the action, and the second adds a relevant limitation. There is minimal waste, though 'read-only' is somewhat redundant with the readOnlyHint annotation. It is concise and scannable, but a bit more actionable guidance would make it stronger.

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 input schema, output schema, and safety annotations, the description is minimally viable but not complete. It lacks explicit information about when realtime reporting is appropriate, how far back the data extends, and how this tool relates to ga4_run_report. The schema fills in parameter details, but the usage context remains 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 100%, so the parameter descriptions already document propertyId, metrics, dimensions, filters, minuteRanges, and other fields. The description adds general context that realtime dimensions and metrics are limited, but it does not add specific parameter-level meaning. Baseline 3 is appropriate because the schema carries the semantic load.

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: 'Run a read-only GA4 Data API realtime report.' It is clear that this tool executes realtime reports and is not a historical report tool. However, it does not explicitly contrast itself with sibling tools like ga4_run_report or ga4_run_pivot_report beyond the word 'realtime,' so differentiation is present but not fully spelled out.

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 says realtime supports only a limited subset of dimensions and metrics, which is a caution but not a usage guideline. It does not state when to choose this tool over ga4_run_report or when to avoid it, nor does it mention the realtime data timeframe. An agent must infer the intended use from the tool 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, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds auto-pagination behavior and dimension/metric maxima, but does not discuss quota handling, invalid-field errors, or what 'intelligent query planning' does in practice.

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 with no fluff: purpose, resource source, and constraints. The most important information is front-loaded, and every sentence earns its place.

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

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

With an output schema and 100% parameter coverage, the description doesn't need to explain return values or each parameter. It adds the key limits and resource links needed to invoke the tool correctly, though it lacks usage routing guidance.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds cross-parameter constraints ('Max 9 dimensions + 10 metrics per request') and directs agents to ga4:// resources for valid metric/dimension keys, which goes beyond the individual parameter 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 states a specific verb+resource: 'Run a GA4 analytics report' with 'intelligent query planning'. It also mentions unique capabilities (52 metrics, 63 dimensions, auto-pagination) that distinguish it from realtime or pivot siblings, though it does not explicitly name 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?

There is no explicit guidance on when to use this tool versus ga4_run_realtime_report, ga4_run_pivot_report, or ga4_validate_query. It gives resource-lookup advice (ga4://metrics, ga4://dimensions) and request limits, but no exclusions or alternative 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral detail about the specific validation rules enforced (9 dims, 10 metrics, ecommerce rules, dimension compatibility), going beyond what annotations alone 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 dense sentence front-loads the purpose ('Validate BEFORE executing') and lists the specific checks without any filler or redundant restatement of the title. Every clause earns its place.

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

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

For a straightforward two-parameter validation tool with a full output schema and strong annotations, the description covers what the tool checks and when to run it. Minor gaps remain, such as clarifying the result/response shape, but the output schema can carry that burden.

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

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

Schema description coverage is 100%, so both parameters are already documented ('Metric keys to validate' and 'Dimension keys to validate'). The description adds the validation context and limits but does not add parameter-level meaning beyond the schema. 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 uses a specific verb, 'Validate', names the resource ('a metric/dimension combination'), and states the functional scope: max limits, ecommerce rules, and dimension compatibility. This clearly distinguishes it from execution tools like ga4_run_report and from diagnostic sibling tools.

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 explicitly positions the tool as a pre-execution gate ('BEFORE executing'), which is clear usage context. However, it does not mention exclusions or explicitly differentiate from the closely named sibling ga4_check_compatibility, so it stops short of full guidance.

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