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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the function without revealing traits such as network activity, runtime expectations, public-URL requirements, or whether the audit affects the target site. It does not contradict any annotations, but it adds little behavioral context beyond the one-line purpose.

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, direct sentence with no filler. It front-loads the action and resource, making it easy to parse quickly.

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 three parameters, no output schema, and close siblings, the description is underspecified. It omits how the standard parameter changes the audit, what includeHidden does, and what kind of results the agent should expect. An agent can call it with only the required URL, but cannot make informed choices about optional inputs or interpret behavior confidently.

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

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

Schema description coverage is only 33%, so the description must compensate for the undocumented 'standard' and 'includeHidden' parameters. It does not, leaving the agent to guess what WCAG standards are selectable and what 'includeHidden' controls. The enum on 'standard' provides some self-documentation, but the description adds no parameter 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 states a specific verb ('Runs an accessibility audit'), a resource ('a webpage'), and the method ('using Lighthouse accessibility checks'). It is clear and distinct from the focused a11y_check_contrast and a11y_check_images siblings, though it does not explicitly differentiate itself from the broader lighthouse_audit 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?

No guidance is given about when to use this tool versus alternatives such as lighthouse_audit, psi_analyze, or a11y_check_contrast. An agent must infer when a full Lighthouse accessibility audit is preferred over more targeted checks or other analysis 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'checks', which implies a read-only operation, but it does not disclose whether a URL is required, whether direct color values suffice, whether a network request is made, or what the tool returns. This is minimal behavior information.

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, direct sentence with no wasted words. It front-loads the main purpose and does not repeat information already present in the tool name.

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

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

Given five undocumented parameters, no output schema, and no annotations, the description is too sparse to guide correct invocation. It does not clarify how 'url' relates to 'background' and 'foreground', whether WCAG AA/AAA levels are reported, or what response an agent should expect. The description is adequate only as a label, not as a complete tool contract.

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

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

Schema description coverage is 0%, and the input schema has no descriptions for any of the five parameters. The description gives a high-level hint that foreground/background colors are involved and that isBold/fontSize may matter for WCAG thresholds, but it does not explain any parameter's meaning, syntax, or which combinations are valid.

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 ('Checks') and resource ('color contrast ratios for WCAG compliance'), which clearly identifies the tool's core function. It is distinguishable from siblings like a11y_audit and a11y_check_images, though it does not explicitly name them.

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

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

There is no guidance on when to use this tool versus alternatives, such as a11y_audit or a11y_check_images. The description implies its purpose but provides no context about which scenarios warrant calling it or what the tool requires.

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

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

No annotations are provided, so the description carries the full burden. 'Checks' implies read-only analysis, but it doesn't disclose return format, whether it reports issues, or any side effects, leaving the agent to infer 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?

One sentence, no filler, front-loaded with the core action. It is concise, though too terse to include richer 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?

Simple tool with one param and no output schema, but the description doesn't describe the result shape or what 'proper alt text' analysis entails, so the agent may not know what to expect from the 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 covers the only parameter with a description ('URL to check for image accessibility'), so the tool description adds no additional meaning 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?

Description states a specific verb 'Checks' with resource 'images' and the target concern 'proper alt text and accessibility'. It distinguishes from siblings like a11y_audit (broader) and a11y_check_contrast (contrast-specific), though it doesn't name them 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?

No explicit when/when-not guidance or alternative routing. The intended situation (verify image alt text on a page) is implied by the purpose, but there are no exclusions or comparisons to sibling audit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Gets a summary' implies a read-only operation, but it does not explain what metrics are included, how date ranges are interpreted, whether authentication/account access is required, or what limitations exist.

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, concise sentence with no wasted words. It is front-loaded with the main action and resource, making it easy to parse quickly.

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 no output schema, no annotations, and only a one-sentence description, the definition is incomplete. An agent is not told what metrics the summary contains, what the response structure looks like, or what edge cases may apply to the date range or customer ID.

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

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

Schema description coverage is only 50%, and the description adds no paramter-level meaning beyond the schema. It does not clarify the expected format of customerId beyond the schema's 'Google Ads Customer ID' or the semantics of the dateRange object, such as inclusivity or timezone handling.

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 ('Gets') and resource ('account performance metrics'), making the core purpose clear. It hints at account-level scope, which loosely distinguishes it from campaign-level ad tools, but it does not explicitly name or contrast any sibling 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 guidance about when to use this tool over alternatives like ads_campaign_performance or ads_get_campaign. The account-level phrasing implies a context, but no when-to-use or when-not-to-use information is provided.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It only states that keywords are added and does not disclose consequences for duplicates, whether existing keywords are modified, required permissions, error conditions, or whether the operation is idempotent. For a mutation tool this is a meaningful gap.

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 short sentence with no filler or redundancy. It is front-loaded and easy to parse, though it sacrifices useful context for brevity.

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 relatively simple and the schema fully documents the required parameters, but with no annotations and no output schema the description leaves behavioral questions open, such as duplicate handling, bid defaults, and whether finalUrl or status are optional. It is minimally sufficient but not complete for a mutating 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%, so the parameters are already documented in the input schema. The description adds no new semantic meaning beyond the schema, which is acceptable but earns only 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 clearly states the action (adds), the object (keywords), and the target context (ad group). It is specific enough to distinguish this from listing or fetching keywords among the sibling tools, though it does not name the platform or mention any constraints that would set it apart from similar create operations.

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

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

There is no guidance about when to use this tool versus related tools such as ads_list_keywords, ads_get_keyword_ideas, or ads_update_campaign. No preconditions, restrictions, or alternative conditions are mentioned, so an agent must infer appropriate usage 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?

With no annotations provided, the description carries the full behavioral disclosure burden, but it only says 'Gets... metrics for a date range.' Read-only intent is implied by the word 'Gets,' but nothing is disclosed about aggregation level, which metrics are included, date-range limits, timezone handling, or the shape of the response.

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 wasted words: verb, object, and scope in that order. The brevity is clean and readable. The thinness of content is a completeness problem, not a structure problem, so it isn't double-penalized here.

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 metrics tool with 3 parameters, a nested dateRange object, and no output schema, a one-sentence description is insufficient. An agent needs to know what metrics are returned (impressions, clicks, conversions, cost), what the optional campaignId does, and which of the many performance-report siblings this replaces. The contract of the tool remains underspecified.

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 only 33% (customerId is the only described parameter; campaignId has no description and dateRange sub-fields only carry format strings). The description mentions 'date range' and 'campaign,' loosely mapping to two parameters, but it adds no semantics for the optional campaignId filter or what happens when it's omitted. Low schema coverage requires more compensation than this.

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: 'Gets campaign performance metrics for a date range.' The 'performance metrics' phrasing clearly signals aggregated metrics data rather than campaign administration. However, it doesn't explicitly differentiate from near-siblings like ads_get_campaign, ads_list_campaigns, or ads_account_summary, so the agent must infer the 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?

There is no when-to-use guidance at all. The description never explains when to choose this over ads_search_term_report, ads_account_summary, gsc_query_performance, or gbp_performance_report, nor does it note that campaignId is an optional filter. The only hint is the 'date range' scope, which is implicit context rather than 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?

No annotations are provided, so the description carries the full behavioral burden. It states only that a budget is created; it does not disclose permissions, side effects, idempotency, defaults, or what the result of the creation looks like. This is insufficient for a mutation tool with no 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 concise sentence with no filler. It front-loads the primary action and adds a useful qualifier, though it is somewhat repetitive with the tool name.

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

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

The tool has no output schema, no annotations, and a nested budget object, which raises the description's burden. The description is too sparse to fully guide an agent on delivery method semantics, defaults, required relationships, or expected results beyond what the schema already provides.

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

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

The schema already documents customerId and amountMicros, but schema coverage is only 50%, leaving deliveryMethod and explicitlyShared unexplained. The description adds no per-parameter meaning beyond the resource concept, so it fails to compensate for the gaps in the optional nested 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?

The descripton uses a specific verb and resource: 'Creates a campaign budget'. The added qualifier 'that can be assigned to campaigns' distinguishes it from ads_create_campaign and other ads 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 a budgeting workflow — budgets are created so they can later be attached to campaigns — but it does not explicitly state when to choose this tool over ads_create_campaign or how it relates to ads_list_budgets. No alternatives or exclusions are named.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool creates a campaign with budget and bidding strategy, but does not mention auth requirements, response behavior, whether a separate budget resource is created, or what side effects occur.

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, efficient sentence with no filler. It front-loads the primary verb and resource and earns its place without redundancy.

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

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

This is a complex mutation tool with a nested campaign object, no output schema, and no annotations. The description is too minimal to fully guide the agent: it omits usage boundaries, behavior after creation, and guidance on conditionally relevant parameters like bidding strategy and targets.

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 description adds high-level context that budget and bidding strategy are part of creation, which maps to schema fields like budgetAmountMicros and biddingStrategyType. However, schema description coverage is only 50%, and the description does not clarify optional fields such as targetRoas, targetCpaMicros, startDate, or endDate.

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: 'Creates a new Google Ads campaign.' It clearly differentiates itself from sibling tools like ads_update_campaign and ads_list_campaigns by emphasizing creation of a new campaign.

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 creation use case clear, implying it is the right tool when a new campaign is needed. It does not explicitly name alternatives or state when not to use it, but the contrast with update/list siblings is reasonably evident.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly indicates a read-only 'get' operation, but provides no additional context about required authorization, possible errors, or what exactly is returned in the campaign details.

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, well-formed sentence with no wasted words. It immediately identifies the action, resource, and 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?

For a simple two-parameter getter with no output schema, the description is minimally adequate: an agent can infer that it should provide both IDs and expect campaign details. However, the vague term 'details' leaves ambiguity about response structure or filtering behavior.

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 both campaignId and customerId described in the schema. The description adds no extra meaning about the parameters, so the baseline score 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?

The description states a specific verb ('Gets') and resource ('details of a specific Google Ads campaign'), which clearly distinguishes it from sibling tools like ads_list_campaigns or ads_get_customer. It conveys exactly what the tool does 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 implies this tool is for retrieving a single campaign's details rather than listing campaigns, but it does not explicitly state when to use it versus alternatives like ads_list_campaigns. There is no clear exclusion or alternative 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?

No annotations exist, so the description must carry the behavioral disclosure burden. It only states 'Gets details,' which implies a read operation, but does not mention auth requirements, rate limits, error behavior, or what fields are included in the 'details.' For a tool with no annotations, this is insufficient.

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 direct sentence with no filler. It is front-loaded with the verb and resource and is appropriately sized for a single-parameter getter.

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 no output schema, so the description should indicate what 'details' means (e.g., account name, currency, time zone, status). It does not, leaving the return shape underspecified. For a simple tool with one parameter, this is a notable gap, though the tool's low complexity prevents a lower score.

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 customerId as a string without dashes. The description adds no additional meaning to the parameter; it only refers to the customer account generally. Baseline 3 applies because the schema carries the 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 a specific verb ('Gets') and a specific resource ('details of a specific Google Ads customer account'). It clearly differentiates from siblings like ads_list_customers (specific vs list) and ads_get_campaign (customer account vs campaign). No ambiguity about what the tool acts 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?

The description provides no guidance on when to use this tool versus alternatives such as ads_list_customers or ads_account_summary. No exclusions or prerequisites are mentioned, leaving the agent to infer the use case from the name and schema.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a read-only intent via 'Gets', but does not disclose output format, authentication requirements, rate limits, seed-selection behavior, or how errors are handled.

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

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

The description is a single front-loaded sentence with no filler. It is appropriately concise, but given the tool's parameter complexity, slightly more structured context would have been beneficial.

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 six parameters, nested objects, no output schema, and no annotations. The description only conveys the high-level purpose and leaves out important contextual details such as seed selection rules, return value shape, and pagination behavior, making it incomplete for reliable invocation.

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

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

Schema coverage is 50%, and the description adds some useful context by linking 'seed keywords or URL' to the keywordSeed and urlSeed parameters. However, it does not clarify whether one seed is required, whether both may be supplied, or what pageSize semantics are beyond the schema's min/max.

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

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

The description states a specific action (gets keyword suggestions) and the inputs ('based on seed keywords or URL'). It is clear enough to identify what the tool does, though it does not explicitly distinguish it from sibling tools like ads_list_keywords or ads_add_keywords.

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 alternatives, such as ads_list_keywords for existing keywords or ads_add_keywords for adding keywords. The intended use case is implied by the name but not explicitly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Lists' implies a read operation, but nothing is disclosed about default result limits, whether campaignId scopes the results or is optional, whether the status filter defaults to a specific value, or whether all accounts' ad groups are returned. The min/max on limit hints at a 10,000-cap, but the description itself is silent on behavior that an agent would need to know to call this correctly.

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 single sentence 'Lists ad groups in a Google Ads account' is efficiently front-loaded and free of filler. However, it errs on the side of under-specification rather than genuine conciseness — it is short because it omits valuable information, not because it has distilled everything important into few 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 4 parameters, 25% schema coverage, no output schema, and no annotations, one clause is insufficient. It does not explain the customer → campaign → ad group hierarchy (whether campaignId is needed to disambiguate), the interaction between status and limit, default behaviors, or how the response is shaped. An agent cannot fully determine correct invocation parameters beyond the required customerId.

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 only 25% — only customerId has a description ('Google Ads Customer ID'). The description adds no meaning for campaignId (what does it filter by?), status (what does filtering do?), or limit (what is the default?). A 4-parameter tool with a bare description and sparse schema documentation leaves most parameter semantics undefined, which is a significant gap the description fails to compensate for.

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') with a clear resource ('ad groups') and scope ('Google Ads account'). It distinguishes itself from sibling tools like ads_list_campaigns and ads_list_keywords by naming 'ad groups' explicitly, so an agent can tell them apart. It could add more context about the campaign hierarchy, but the core purpose is unambiguous.

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

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

No guidance is given on when to use this tool versus the many ads_* siblings such as ads_list_campaigns, ads_list_keywords, or ads_get_campaign. There are no exclusions, no alternative recommendations, and no mention of the Google Ads hierarchy (customers → campaigns → ad groups) that would help an agent decide when a campaignId is necessary. The usage context must be entirely inferred from the tool name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the operation ('Lists campaign budgets') and does not mention pagination, default limit, response shape, or whether shared budgets are included. The description does not contradict anything, but it leaves important behavior unspecified.

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 action and resource front-loaded and no filler. Every word contributes to defining what the tool does.

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

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

For a simple two-parameter list operation, the description plus schema is nearly sufficient for selecting and calling the tool. However, there is no output schema and the description does not specify default limits, pagination behavior, or return value shape, leaving some gaps an agent would need to resolve.

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 50%, with customerId described but limit left to its min/max constraints. The description adds no parameter-level meaning, so the agent gets no help understanding how limit affects the listing or what customerId format is expected beyond the schema's one-line description.

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

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

States a specific verb ('Lists'), a distinct resource ('campaign budgets'), and an account scope. This clearly distinguishes it from sibling tools such as ads_list_campaigns and ads_create_budget without needing to inspect their schemas.

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

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

The description gives no guidance on when to choose this tool over related Ads tools. It does not mention how it relates to ads_list_campaigns, ads_account_summary, or ads_create_budget, nor any prerequisites or exclusions, so the agent must infer usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Lists' implies a read-only operation, but the description says nothing about whether removed campaigns are returned, what the default limit or pagination behavior is, how filters combine, or what access is required. Almost no behavioral detail is disclosed.

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

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

A single seven-word sentence with no filler; every word earns its place and the purpose is front-loaded. Its brevity is appropriate for a simple list operation, though a second sentence on usage or defaults would have been more helpful.

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 tool has four parameters, two enums, no annotations, no output schema, and only 25% schema description coverage — so the description is the only channel for explaining defaults, filter interaction, pagination (the limit max of 10000 hints at it), and return shape. The single sentence covers none of these, leaving an agent to guess at runtime behavior.

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 only 25% (only customerId is described), so the description needed to compensate for the undocumented type, limit, and status parameters—but it does not. It adds no meaning about how these filters shape the result set; whatever semantics exist come from the enum values in the schema itself.

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 a specific resource ('campaigns in a Google Ads account'), making the core operation clear. However, it does not explicitly differentiate itself from sibling tools such as ads_get_campaign (single campaign) or ads_campaign_performance (metrics), 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 use this tool versus alternatives. It never mentions ads_get_campaign for retrieving one campaign, ads_campaign_performance for reporting, or ads_list_ad_groups for a different resource level, leaving the agent to infer selection purely from the tool name.

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

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

With no annotations available, the description carries the full behavioral burden. 'Lists' clearly signals a read-only operation, and 'accessible to the authenticated user' explains the authorization-based scope. It does not mention pagination or output details, but for a zero-parameter list tool the essential behavior is disclosed.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning: the action, the resource, the scope, and the authentication 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?

For a simple zero-parameter list tool with no output schema, the description is largely sufficient. It clearly states what is returned conceptually—all accessible customer accounts—though it could optionally note that the returned customer identifiers are used by downstream ads_* 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?

The tool has zero parameters, so the input schema is trivially complete with 100% coverage. The description correctly does not try to invent parameter guidance. Per the guideline, 0 parameters warrants a baseline of 4.

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 a specific resource, 'Google Ads customer accounts', while adding the important scope qualifier 'accessible to the authenticated user.' This clearly distinguishes it from sibling tools like ads_get_customer, which targets a single customer.

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 conveys the context: use this when you need to enumerate all Google Ads customer accounts the current user can access. It does not explicitly name alternatives or exclusions, but the all-vs-single distinction is strongly implied by the wording.

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?

There are no annotations, so the description carries the full burden for behavioral disclosure. It only states that the tool lists keywords, with no mention of read-only behavior, pagination, default filters, ordering, or required authentication context. This is a minimal statement of operation rather than a disclosure of behavioral traits.

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 redundant content. It earns its place but is limited in substance; however, for a simple list operation, the structure is appropriate and concise.

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

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

With no output schema and no behavioral annotations, the description is too sparse to fully inform an agent. It does not clarify return format, whether adGroupId or campaignId are required filter contexts, what status defaults to, or how limits behave. The tool has five parameters, so the single-sentence description leaves significant 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 only 20%, with customerId being the only documented parameter. The description adds no meaning to limit, status, adGroupId, or campaignId, and does not explain how filters combine or affect results. Although the parameter names are somewhat self-explanatory, the description fails to compensate for the low 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 clearly states the verb 'lists' and the resource 'keywords in a Google Ads account,' making the basic purpose obvious. It does not explicitly differentiate from sibling tools like ads_add_keywords or ads_get_keyword_ideas, but the listing action is unambiguous.

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

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

No guidance is provided about when to use this tool versus alternatives, nor are any exclusions or related tools mentioned. The description simply states what it does, leaving the agent to infer appropriate usage from the name and 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It indicates a read-only report, but does not mention pagination via limit, filtering by campaign/ad group, date range handling, report latency, data aggregation, or output shape. This is too thin for a report tool.

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

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

The description is short and front-loaded, with no wasted words. However, it is under-specified for a tool with six parameters and a nested object; the brevity reads more as omission than as disciplined conciseness.

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 absence of annotations and output schema, plus low parameter coverage, the description is not complete enough for an agent to invoke the tool confidently. It lacks guidance on required inputs, filters, pagination, and what the returned report contains beyond 'actual user queries.'

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 only 17%, and the description adds no parameter-level meaning. It does not explain customerId, dateRange, campaignId, adGroupId, or limit. With such low coverage, the description was expected to compensate but instead merely restates the report's content.

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 ('Gets') and a concrete resource ('search terms report'), and adds clarifying context ('showing actual user queries') that distinguishes it from keyword-related tools like ads_list_keywords. However, it does not explicitly compare against sibling tools, so differentiation is implied rather than stated.

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

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

There is no guidance on when to use this tool instead of alternatives such as ads_list_keywords or ads_get_keyword_ideas. The phrase 'actual user queries' hints at one use case, but no explicit context, exclusions, or alternative tool references are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool updates an existing campaign, disclosing nothing about whether updates are partial (PATCH-like) or full replacement, what happens to omitted fields like name or endDate, required permissions, idempotency, or failure behavior. For a mutation tool with zero annotation coverage, this is a significant gap.

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 efficient sentence with the verb front-loaded and no wasted words. The minor grammatical awkwardness of 'campaign settings' (rather than 'campaign's settings') is trivial and does not impede understanding.

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 write operation with a nested schema, no output schema, and no annotations, yet the description is one sentence. It omits what the response contains, whether updates apply atomically or partially, and behavior on invalid campaignId or customerId. An agent lacks enough context to anticipate side effects or validate success.

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 67%: customerId and campaignId are described in the schema, but the nested 'updates' object has no schema description and is the most complex parameter. The description's phrase 'campaign settings' only vaguely maps to the updates object and adds no semantic detail such as budgetAmountMicros being in micros or endDate format expectations. The description fails to compensate for the undocumented nested parameter.

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

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

The description states a specific verb ('Updates') and resource ('existing Google Ads campaign settings'), and the word 'existing' implicitly distinguishes it from ads_create_campaign while the update verb separates it from read-only siblings like ads_get_campaign and ads_list_campaigns. However, it never names a sibling explicitly and 'campaign settings' is slightly vague about scope, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list contains ads_create_campaign and ads_create_budget, which are natural alternatives for create-versus-update and budget scenarios, but the description never references them or states any exclusion conditions. An agent must guess when an existing campaign requires update rather than creation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing what 'status' includes, whether it performs a network request, or what kind of response the agent should expect. This is a significant gap for a status-checking tool.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, making it appropriately concise for a simple status-checking tool.

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

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

For a zero-parameter tool this is mostly complete, but with no output schema and no annotations, the agent has no idea what the return value looks like (e.g., a boolean, a status string, or an object with per-provider status). A brief note on the response shape would make it fully self-sufficient.

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 has zero parameters and 100% schema coverage, so there is nothing for the description to add. Per the rubric, a zero-parameter tool earns a baseline of 4, and the description satisfies that 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 uses a specific verb ('Get') and resource ('current authentication status'), making the tool's purpose immediately clear. It is distinct from sibling status tools like rate_limit_status and indexing_get_status, which reference different resources.

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 on when to call this tool, such as verifying credentials before making authenticated requests or troubleshooting 401 errors. There are no stated alternatives or exclusions, leaving the agent to infer the context entirely.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a read operation via the word 'Get' but discloses nothing about what the statistics represent, what scope they cover, whether authentication is needed, or what the return format 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?

The description contains only two substantive words, which is under-specification rather than genuine conciseness. There is no structure to evaluate — no scoping constraint, no example, no clarification of what 'cache statistics' means.

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

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

With no output schema and no annotations, the description needs to explain what the tool returns and why an agent would call it. 'Cache statistics' is too ambiguous to be complete — an agent cannot tell whether this is a Cloudflare metric, a server-level stat, or something else entirely.

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 is empty with zero parameters, so there is nothing for the description to clarify. The 0-parameter baseline of 4 applies; the description cannot add meaning where no parameters exist.

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 'Get cache statistics' is essentially a verb-prefixed restatement of the tool name 'cache_stats' — it expands 'stats' to 'statistics' but adds no new information. It never specifies which cache (e.g., Cloudflare, given the cf_purge_cache sibling) or which statistics are returned, so it borders on tautology rather than a genuine purpose statement.

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

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

There is no guidance on when to use this tool versus alternatives. Sibling tools include cf_purge_cache, cf_get_analytics, and various monitor_* tools, but the description gives no context about how cache_stats relates to them or what situation calls for it.

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

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

No annotations are provided, so the description carries the full behavioral burden, but it only discloses that the tool mutates state by creating a record. It does not mention side effects, duplicate handling, propagation delays, permission requirements, or expected response 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?

The description is a single, front-loaded sentence with no filler or redundancy. It conveys the core action and resource efficiently, though it sacrifices semantic richness for brevity.

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 7 parameters, no annotations, and no output schema, this description is incomplete. It does not clarify return values, record-type-specific behavior, defaults for optional fields, or the relationship to other Cloudflare tools, leaving the agent with only the schema to work from.

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 description adds no parameter information beyond what the schema already provides. With schema coverage at 57%, the description fails to compensate for undocumented fields like proxied, ttl, and priority, which are meaningful for DNS record creation.

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 ('Creates'), a concrete resource ('new DNS record'), and a scoped context ('in a Cloudflare zone'). This clearly distinguishes the tool from read-only siblings like cf_list_dns_records and cf_get_zones.

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

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

There is no guidance on when this tool should be used versus alternatives, no prerequisites (e.g., needing a zone ID from cf_get_zones), and no mention of when a different tool would be more appropriate. Usage context is only implied by the name and action.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely restates that the tool fetches events and adds no context about pagination, date/time semantics, limits, rate restrictions, or possible failure modes.

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 and leads with the verb and resource. It is concise, though the brevity comes at the cost of helpful 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 five parameters, no output schema, and no annotations, the description is too sparse. The optional filters 'since', 'until', 'limit', and 'action' are left ambiguous, so an agent cannot confidently construct a correct call beyond providing a zoneId.

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 only 20%, with only zoneId explained. The description does not define 'since', 'until', 'limit', or the intended meaning of 'action' despite the enum, so it fails to compensate for the low 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 identifies a specific action (Gets) and resource (firewall events for a Cloudflare zone), which is enough to distinguish it from unrelated siblings like cf_list_dns_records or cf_purge_cache. However, it does not explicitly contrast it with partially overlapping tools like cf_get_analytics.

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

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

There is no guidance about when to use this tool versus alternatives, nor any stated exclusions or prerequisites beyond the implied need for a zone. The description only conveys the resource type, leaving selection entirely to inference.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only restates the basic operation without revealing metric types, granularity, rate limits, auth needs, or what 'analytics' actually contains.

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

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

The description is concise and front-loaded, with no filler words. However, it is so minimal that it conveys little beyond the tool name itself, reducing its informational value.

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

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

With no annotations and no output schema, the description is too sparse for an agent to know what analytics metrics will be returned, how since and until interact, or what errors are possible. A caller is left mostly to inference.

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 67%: since and zoneId have descriptions, but until is only typed as a string with no explanation. The tool description adds no additional meaning about the parameters or their relationships.

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 clear verb ('Gets') and identifies the resource ('analytics data for a Cloudflare zone'). It distinguishes the tool from sibling Cloudflare tools like cf_get_zones and cf_list_dns_records, though it does not specify which analytics metrics or time windows are included.

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

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

There is no guidance on when to use this tool versus related tools such as dashboard_overview, cache_stats, or cf_get_zones. The description does not mention prerequisites like zone access, nor does it exclude any alternatives.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does convey that this is a read-only listing operation scoped to the authenticated user. However, it does not mention pagination behavior, default per-page values, rate-limit implications, or what fields the returned zones contain.

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. It states the core action and scope 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?

For a tool with no annotations, no output schema, and no parameter descriptions, this description is too thin. It does not explain what a returned zone looks like, how filtering or pagination works in practice, or how this list might feed into later Cloudflare operations. An agent can invoke it, but not confidently reason about its results.

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

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

Schema description coverage is 0%, and the tool description provides no explanation of the 'name', 'page', 'status', or 'perPage' parameters. The schema only gives types/enums, so the agent receives no semantic guidance beyond raw parameter names.

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 ('Lists'), a precise resource ('Cloudflare zones'), and a scope ('accessible to the authenticated user'). It is immediately distinguishable from sibling Cloudflare tools like cf_list_dns_records or cf_purge_cache.

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

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

There is no guidance about when to use this tool versus alternatives, no suggested workflow, and no mention of sibling tools that might serve related purposes. The intended use is implied but never 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Lists' implies a non-destructive read, but nothing is said about pagination behavior, filtering semantics, rate limits, or what the response contains. For a tool with page/perPage parameters, the absence of any pagination note is a notable gap.

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 efficient sentence with no wasted words, but it largely restates the tool name (cf_list_dns_records → 'Lists DNS records'). This is under-specification rather than deliberate brevity; there was room to add filtering or pagination context without bloating the description.

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 5 parameters, no output schema, and no annotations, a single sentence is inadequate. Missing guidance on how zoneId is obtained, what type/name filters do, and pagination behavior leaves the agent to experiment or read the schema. The definition is not catastrophic (the resource is clear), but it is far from complete for a tool with this parameter count.

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 only 20%, so the description should compensate, but it mentions no parameters at all. Only zoneId has an inline description in the schema; name, page, type, and perPage are left to inference. The description adds zero value beyond what the parameter names already convey.

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

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

States a specific verb ('Lists') and resource ('DNS records for a Cloudflare zone'), clearly identifying a read operation scoped to Cloudflare. It is distinguishable from cf_create_dns_record (write) and cf_get_analytics by resource, though it doesn't explicitly contrast with monitor_dns_lookup.

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 on when to use this tool versus alternatives. It doesn't mention that cf_get_zones would be needed to obtain the zoneId, nor how it differs from monitor_dns_lookup or monitor_dns_propagation for DNS inspection. The agent must infer the use case entirely from the tool name.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It states that cache is purged, which signals a state-changing operation, but it does not mention whether the purge is irreversible, whether purgeEverything and selective purging are mutually exclusive, or what the impact is on cached content. This is a material gap for a destructive operation.

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 concise and readable, though it sacrifices useful detail; the brevity is a strength structurally but contributes to the incompleteness already penalized.

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 state-changing operation with no annotations, no output schema, and low parameter documentation. The description covers only the high-level action and scope, leaving out parameter relationships, expected return values, and operational constraints, so it is not complete enough for an agent to invoke reliably.

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 only 17%, with zoneId being the only documented parameter. The description adds nothing about tags, files, hosts, prefixes, or purgeEverything, and fails to explain the selective-versus-full purge relationship. An agent cannot determine the semantics of five of the six parameters from the description or 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?

The description uses a specific action verb ('Purges') with a clear resource ('Cloudflare cache') and scope ('for a zone'). It is unambiguous about what the tool does, but it does not explicitly distinguish itself from sibling cache-related tools like cache_stats or cf_get_analytics.

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

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

No guidance is given about when to use this tool rather than an alternative, when not to use it, or prerequisites such as zone ownership. The only implied context is that it is for purging cache, which is not enough to help an agent choose among the many sibling 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?

No annotations are provided, so the description carries the full burden. It discloses only the temporal nature of the data ('historical') and implies read-only via 'Gets'. It says nothing about how far back data goes, time-range granularity, whether both url and origin can be supplied, API quota limits, or failure behavior — all material for a data-fetching tool.

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

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

An 11-word single sentence with zero waste, front-loaded with the verb and resource. It is efficient, though the brevity trades away the parameters and alternatives value that other dimensions require.

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 four undocumented parameters, zero annotations, and no output schema, a one-liner is not enough. The agent is left without param semantics, valid metric values, usage boundaries vs crux_query, or any sense of the return shape — gaps that the description was the only place to fill.

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

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

Schema description coverage is 0% with four undocumented parameters, yet the description compensates not once by mentioning url, origin, metrics, or formFactor. An agent cannot know the difference between URL-level and origin-level CrUX data, which metrics are valid, or the meaning of the optional formFactor enum beyond its literal values.

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 ('Gets') and resource ('historical Chrome UX Report data') plus an explicit purpose ('for trend analysis'). The word 'historical' differingentiates it at least implicitly from the sibling crux_query, though it never names that tool and leaves the contrast 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?

The phrase 'for trend analysis' provides implied usage guidance — an agent can infer it should be selected when historical/trend analysis is the goal rather than single-point queries. However, it gives no explicit when-not-to-use guidance and names no alternative (cRux_query, cWyv_report, psi_analyze), so the routing decision is left to the agent.

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

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

No annotations are present, so the description carries the burden of explaining behavior. It implies a non-destructive read operation, but it does not disclose whether authentication is needed, whether at least one of url/origin is required, how much data is returned, or what performance metrics are actually included. This is minimal transparency beyond the bare action.

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 concise sentence with no filler and the core action is front-loaded. However, it is short mainly because it omits important usage and behavioral details, so it is concise but not richly informative.

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 four parameters, no required flags, no output schema, and no annotations, the description leaves the agent unsure about how to form a valid call, what the response looks like, and what constraints apply. It communicates the basic purpose but is not complete enough for correct invocation.

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

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

Schema description coverage is 0%, and the description adds no meaning to the four parameters: url, origin, metrics, and formFactor. It does not explain what each parameter controls, whether url and origin are mutually exclusive, or what metric strings are valid beyond the enum values already visible in the schema. The description entirely fails to compensate for the missing 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, 'Queries', and identifies the resource, 'Chrome UX Report data', along with the purpose, 'real-world performance metrics'. This clearly states what the tool does, but it does not differentiate it from sibling tools like crux_history, cwv_report, or psi_analyze, which could overlap in purpose.

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 about when to use crux_query versus alternatives. There is no mention of whether to pass a url or origin, whether both are needed, what kind of report this returns, or when a sibling like crux_history would be more appropriate. The agent receives no routing help.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals nothing about data source (CrUX field data vs. synthetic measurement), what 'comprehensive' means (which metrics: LCP, INP, CLS), whether it performs external API calls subject to rate limits, how includeHistory alters behavior, or the format/latency of the report.

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 no filler, front-loading the core action and resource. It is appropriately terse for a two-parameter tool, though the brevity does contribute to the under-specification penalized in other dimensions.

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

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

With no output schema, no annotations, and a sibling cluster of performance tools (crux_query, crux_history, psi_analyze, lighthouse_audit), the description should do more to contextualize what the report contains and how it differs. An agent cannot determine whether this is the right tool for field-data CWV analysis, historical trends, or lab audits.

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 50%: the 'url' parameter is documented in the schema, and 'includeHistory' is self-explanatory from its name. The description adds little parameter-level insight beyond 'for a URL', which merely echoes the schema, but it does not actively mislead and the parameter meanings are reasonably inferable.

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 ('Generates'), a resource ('Core Web Vitals report'), and a target ('for a URL'), so the agent knows what the tool produces. However, it does not distinguish itself from performance-related siblings such as psi_analyze, crux_query, crux_history, or lighthouse_audit, which an agent could reasonably 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?

There is no guidance on when to use this tool versus the many overlapping performance and monitoring siblings. The description does not mention data source differences (e.g., field data from CrUX vs. lab data), speed, or any conditions under which an alternative would be preferable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal that output is formatted markdown, which is useful, but it does not disclose whether the tool performs live checks, what data sources it aggregates, any authentication requirements, or failure behavior. For a tool combining multiple data categories, this lack of behavioral context is a notable gap.

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 efficient sentence with no filler words. It front-loads the primary action and outcome, then adds the markdown format detail that is relevant for an agent choosing and invoking the 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?

There is no output schema, so the description should clarify what the returned markdown contains, but it only vaguely references 'site health' and 'SEO audit data'. An agent cannot predict the structure, length, or key sections of the output, nor whether multiple network calls or specific permissions are needed. For a tool that aggregates diverse data, this is insufficient 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?

The input schema has 100% description coverage and the single parameter 'url' is already described as 'URL to analyze'. The tool description adds no additional meaning about how the URL is used or validated beyond schema information. Baseline 3 is appropriate since the schema fully documents the parameter.

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

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

The description specifies a clear action ('Generates') and resource ('unified dashboard overview') while indicating it combines site health and SEO audit data into markdown output. This distinguishes it from the many single-purpose sibling tools like seo_meta_analyze or monitor_check_uptime. It could be more precise about what 'site health' encompasses, but the core purpose is understandable.

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 phrasing implies this tool is for getting a consolidated overview rather than individual metric details, but it does not explicitly state when to use it versus calling monitor_* or seo_* tools directly. No alternatives are named and no exclusion criteria are given. The usage context is only implied, not explicitly guided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that details are retrieved, with no mention of authentication expectations, error behavior, response shape, or any consequences. For a simple read operation this is sparse but not misleading.

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 concise sentence with no fluff or redundant wording. It is front-loaded with the main action and resource, though its brevity leaves room for additional helpful 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?

For a simple one-parameter getter, the description is minimally viable but not complete. Since there is no output schema, the agent is not told what 'details' are returned, and no guidance is given about how this tool relates to the GA4 account listing 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%, and the accountId parameter is already described as 'GA4 Account ID (numeric ID or full resource name)'. The description adds no additional meaning or context about the parameter beyond what the schema already provides, 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 clearly identifies the verb ('Gets') and resource ('details of a specific GA4 account'), which makes the tool's purpose understandable. However, it does not explicitly distinguish it from sibling tools like ga4_list_accounts or ga4_get_property beyond the word 'specific'.

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 'specific GA4 account' implies this tool should be used when the caller already knows the account ID, rather than listing accounts. No explicit guidance is given about when to use this tool versus ga4_list_accounts or ga4_get_property, so the usage context is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates a read-only metadata operation, but it does not describe the response structure, whether custom dimensions/metrics are included, or how the propertyId is validated. The core behavior is visible, but deeper behavioral context is missing.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. Every word contributes to defining the operation and the object it operates on.

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 fully documented required parameter and no output schema, the description states both the action and the expected output type ('available dimensions and metrics'). It is nearly complete, though adding a note about using this before running GA4 reports would strengthen it further.

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 parameter with 'GA4 Property ID', so schema coverage is 100%. The description adds no extra semantic detail about the parameter beyond what the schema already provides, 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 uses a specific verb ('Gets') and a precise resource ('available dimensions and metrics for a GA4 property'), making the tool's purpose immediately clear. It also distinguishes itself from sibling tools like ga4_get_property and ga4_run_report by focusing on metadata discovery rather than property settings or report data.

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 the tool is used when an agent needs to know which dimensions and metrics are available for a GA4 property, but it does not explicitly state when to prefer this over related tools such as ga4_list_custom_dimensions or ga4_run_report. There are no usage exclusions or alternative tool references.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Gets details'. It does not mention auth requirements, rate limits, side effects, or what details 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?

A single front-loaded sentence with zero extraneous text. Every word contributes to defining the operation.

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 getter with no output schema, the description plus fully documented schema is sufficient for an agent to select and invoke it correctly. It is thin on behavioral expectations, but the operation is simple and non-destructive.

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

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

The schema already fully documents propertyId, including accepted value forms, so the description adds no new parameter semantics. Baseline 3 applies because schema description coverage is 100%.

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 uses a specific verb ('Gets') and resource ('details of a specific GA4 property'), clearly distinguishing it from list-style siblings like ga4_list_properties and ga4_get_account. The scope is unambiguous.

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

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

No guidance is provided on when to use this tool versus ga4_list_properties or ga4_get_account. The intended use is inferable from the name, but the description does not state prerequisites, alternatives, or exclusions.

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

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

With no annotations provided, the description carries the disclosure burden. 'Lists' implies a read-only operation and the scope is stated, but there is no mention of pagination behavior, response structure, or any rate-limit considerations. The behavior is safe and predictable but not richly described.

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 key verb, resource, and scope are front-loaded, making it immediately actionable for an agent.

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 list tool with no required parameters, the description covers the core purpose. However, the absence of an output schema and the lack of any mention of pagination means the agent is left to infer how to retrieve all accounts, especially when using pageSize and pageToken.

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

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

Schema description coverage is 0%, and the description does not mention pageSize or pageToken at all. While those parameter names are fairly self-explanatory and the schema provides min/max constraints, the description adds no semantic value about pagination or how these parameters affect the returned account list.

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 the exact resource: all Google Analytics 4 accounts accessible to the authenticated user. This clearly distinguishes it from ga4_get_account, ga4_list_properties, and similar list tools for other systems like GTM or GBP.

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 to enumerate GA4 accounts, and the authentication context is helpful. However, it does not explicitly mention when to prefer ga4_get_account for a single account or explain how pagination should be handled when iterating over all accounts.

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 are absent, so the description carries the full burden. 'Lists' does signal a safe read-only operation, which is the core behavioral trait. However, it does not disclose that reslts are paginated (despite pageSize/pageToken params), what 'configured' includes or excludes, permissions needed, or response format. Adequate for the primary behavior but thin on everything beyond it.

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 with the verb 'Lists' front-loaded and zero fluff. Every word contributes meaning: action, resourse, scope. The description is as efficient as a definition can be.

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

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

For a simple tool — one required param, no nested objects, low polymorphic complexity — the sentence is sufficient to make a correct first call with propertyId. But with no output schema to document return values and two params left unexplained, the agent does not know the response shape, how pagination works, or what an audience entry contains. Minimum viable, no more.

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 only 33%, below the 50% threshold, so the description must compensate — and it does not. 'For a GA4 property' merely restates the schema's existing 'GA4 Property ID' for propertyId. pageSize (number bounded 1–200) and pageToken have no semantics in either the schema or the description, leaving two of three params unexplained.

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

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

Verbs 'Lists' with a specific resourse 'configured audiences' scoped to 'a GA4 property' — unambigous and distinct. The resource name differentiates it from sibling ga4_list_* tools (accounts, properties, custom_dimensions, data_streams, conversion_events), though only implicitely; no explicit boundary statement. Clear enough for an agent to identify the right tool at a glance.

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 on when to use this tool versus alternatives — no mention of sibling tools, no exclusions, no criteria like 'use ga4_list_data_streams for stream-level data instead'. The one-sentence description says nothing about when audiences are the right resourse or what consitutes a 'configured' audiience. An agent must infer usage purely from the tool name and 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It simply restates a read operation without explicitly confirming the read-only nature, explaining that pageSize/pageToken enable pagination, or noting any authorization 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?

The description is a single efficient sentence with no redundant words and is well front-loaded. However, its brevity leaves behavioral and parameter details to be filled by other sources.

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

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

With no output schema and no annotations, a complete description should clarify what a conversion event is, whether the response is paginated, and what the return payload contains. The current text only restates the tool name's meaning and leaves these key details unspecified.

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 only 33%, with propertyId described only as 'GA4 Property ID'. pageSize and pageToken lack descriptions, and the tool description does not compensate by explaining how pagination works or what propertyId targets.

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 specific verb 'Lists' with the resource 'conversion events' scoped to 'a GA4 property'. This clearly distinguishes it from sibling list tools such as ga4_list_custom_dimensions, ga4_list_data_streams, and ga4_list_audiences.

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

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

There is no guidance about when to use this tool versus alternatives, nor any exclusions or related tool suggestions. For example, it does not clarify that ga4_run_report is more appropriate for querying conversion metrics rather than listing configured conversion event names.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the read-like action 'Lists' but does not disclose pagination behavior despite pageSize and pageToken existing in the schema, nor does it describe response shape or any access requirements. This leaves meaningful behavioral context unstated.

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 no redundant words, front-loading the operation and resource. It is appropriately sized for a straightforward list operation and every word contributes meaning.

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

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

For a tool with no annotations, no output schema, and a schema description covering only one of three parameters, the description is too terse. It omits pagination semantics, return value expectations, and any guidance about how to use pageToken or pageSize. An agent would need to infer important call details.

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 only 33%: only propertyId has a description. The description adds only the general context that dimensions are 'defined for a GA4 property', which indirectly reinforces propertyId's role, but it says nothing about pageSize or pageToken semantics. With low schema coverage, the description should compensate, and it does not adequately do so.

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 resource ('custom dimensions defined for a GA4 property'), which clearly identifies the operation. It distinguishes itself from the sibling ga4_list_custom_metrics by naming a different resource type, so an agent can select it without opening the schema.

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

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

The context is implied: use this when you need the custom dimensions for a GA4 property. However, it provides no explicit guidance about when to prefer this over alternatives such as ga4_list_custom_metrics or other GA4 listing tools, and it does not mention pagination as a usage consideration.

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

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

No annotations are provided, so the description carries full burden. It only states a simple listing action. It does not mention pagination behavior (pageSize, pageToken exist in schema), whether it returns all metrics by default, or any side effects (though listing is typically read-only). The presence of pageSize and pageToken implies pagination but the description does not disclose this or any limits.

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 clear, front-loaded sentence with no filler. It states the action and resource 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?

Given the tool has 3 parameters, one required, and no output schema, the description is minimal. It does not explain pagination parameters, the meaning of results, or how this relates to other GA4 tools. For a simple list tool this might be minimally viable, but the pagination parameters and low schema coverage create a gap.

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

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

Schema description coverage is only 33% because only propertyId has a description, while pageSize and pageToken lack descriptions. The tool description adds no parameter details. The schema gives basic type info (number with min/max, string), but pageSize and pageToken are not explained. The description does not compensate for the low 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 'Lists custom metrics defined for a GA4 property' uses a specific verb+resource and gives the scope (GA4 property). However, it does not explicitly differentiate from sibling tools like ga4_list_custom_dimensions, though the phrase 'custom metrics' does distinguish it from other GA4 list 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 usage context: use when you need to list custom metrics for a GA4 property. However, it provides no explicit guidance on when not to use it or mention of alternatives such as ga4_list_custom_dimensions. The schema requires propertyId, which implies the user needs a GA4 property ID, but this is not stated in the 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It implies a read-only listing operation but does not disclose pagination behavior, result ordering, required authentication scope, or whether data streams are nested under a specific property. No mention is made of quotas, errors, or return characteristics.

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

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

The description is a single, front-loaded sentence with no filler, which is concise. However, it is under-sized relative to the operational details an agent would need, so the brevity comes at the cost of completeness.

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

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

With no output schema and no annotations, the description should explain what the response contains, how pagination is controlled, and how this call fits into the GA4 workflow. None of that is present, leaving the tool only minimally viable for an agent deciding whether and how to 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?

Schema description coverage is only 33%: pageSize and pageToken lack descriptions entirely. The description adds no detail about these two parameters or how pagination works, and it only minimally reinforces that propertyId identifies the GA4 property whose streams should be listed.

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 ('Lists') and a distinct resource ('data streams') with an explicit scope ('for a GA4 property'), which is enough to distinguish it from account-level and property-level listing tools. It does not explicitly name sibling alternatives, so it stops short of a perfect differentiation.

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

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

No guidance is provided about when to use this tool versus ga4_list_properties, ga4_get_property, or other GA4 list tools. The intended context is only implied by the tool's name and one-line description, with no mention of alternatives, required prerequisites, or follow-up actions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. The verb 'Lists' conveys read-only semantics and the phrase 'optionally filtered by account' discloses the filter behavior, but pagination behavior (indicated by pageSize/pageToken parameters), auth requirements, and response shape are not mentioned. It covers the essential safety-relevant trait but leaves operational details undisclosed.

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 waste. The action verb leads, the resource follows, and the optional filter is stated in six words. Every word 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 list operation, the core purpose and filter option are complete. However, with no annotations, no output schema, and 0% parameter coverage, the description leaves pagination mechanics (how pageSize and pageToken relate) to inference from parameter names, and says nothing about the response's list format or whether property metadata is nested. Adequate but with a clear gap.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It adds meaning only to accountId via 'optionally filtered by account'; pageSize and pageToken receive no explanation of how they interact (e.g., pageToken being returned from a prior page). The description partially compensates for the coverage gap but leaves two of three parameters semantically under-documented.

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

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

The description states a specific verb (Lists), a precise resource (GA4 properties), and the scope (all, optionally filtered by account). This cleanly distinguishes it from sibling tools like ga4_get_property (single property fetch) and ga4_list_accounts (account-level enumeration), so an agent can select it confidently without opening the schema.

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

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

The purpose statement implies the usage context: call this when you need to enumerate GA4 properties, optionally scoped to an account. However, it provides no explicit when-to-use/when-not-to-use guidance and names no alternatives, leaving the agent to infer routing from sibling names alone.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It only states that the tool 'runs' a funnel report, without clarifying that this is a read-only analytics operation, whether any data is returned, how results are structured, or whether any limits or side effects apply.

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, concise sentence with no wasted words and the core action front-loaded. It is efficient, though slightly under-specified for the complexity of the input 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?

Given the nested funnel object, multiple required parameters, no output schema, and sibling tools that also run reports, this description is too thin. It does not explain the required structure of funnel steps, the meaning of funnel options, or the difference from ga4_run_report, leaving important context 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 only 40%, so the description should compensate by explaining key parameters. It does not mention propertyId, dateRanges, funnelBreakdown, or limit, and only vaguely alludes to 'defined steps.' This leaves agents without enough guidance to construct a valid funnel report.

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 ('runs') and resource ('funnel analysis report') and states the goal of understanding user flow through defined steps. This is clear and informative, though it does not explicitly differentiate from siblings like ga4_run_report or ga4_run_realtime_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 phrase 'to understand user flow through defined steps' implies the tool is for funnel analysis, but it gives no explicit guidance on when to use this tool versus alternatives such as ga4_run_report. No exclusions or alternative routing are mentioned.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It only reveals the 30-minute recency constraint; it does not describe response shape, metric/dimension compatibility, filter semantics, real-time API limitations, or whether the operation is strictly read-only 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?

The description is a single sentence with no wasted words. It front-loads both the tool's purpose and its key time constraint, which is exactly what a concise tool description should do.

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 six parameters, no output schema, no annotations, and opaque filter objects, this description is too thin. An agent cannot confidently construct a fully valid request, especially knowing that metricFilter and dimensionFilter are complete unknowns and there is no guidance about response shape or parameter interactions.

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

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

Schema coverage is only 33%, and the description adds no parameter-level meaning beyond what the schema already contains. The metricFilter and dimensionFilter fields are opaque empty schemas, and the description does nothing to clarify what valid filters look like, so an agent has to guess.

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

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

The description states a specific action and resource: getting real-time data from GA4, with a clear 30-minute window. It does not explicitly name sibling tools like ga4_run_report, but 'real-time' and 'last 30 minutes' serve as meaningful differentiators.

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 30-minute real-time framing implies when to use this tool, but the description does not explicitly say how it compares to ga4_run_report or ga4_run_funnel_report. No exclusions or alternative conditions are provided, so guidance remains implicit.

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

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

No annotations are present, so the description carries the full disclosure burden, yet it only implies a read-only query. It does not disclose pagination behavior (limit/offset up to 100,000 rows), the size or shape of results, or GA4 quota/rate-limit considerations.

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 efficient sentence with no filler, front-loading the action before the resource. It is short, but for a 10-parameter tool the brevity edges toward under-specification rather than disciplined concision, so not 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?

For a tool with 10 parameters, no output schema, and zero annotations, one short clause is inadequate. The agent is left without a response-shape expectation, a pagination strategy, or any contrast against ga4_run_realtime_report / ga4_run_funnel_report / ga4_traffic_overview.

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 only about 30%, so the description must compensate, and it contributes nothing specific about any of the 10 parameters. The loose implication of 'custom report query' (dimensions + metrics + date ranges) is marginal; limit, offset, orderBys, metricFilter, dimensionFilter, and keepEmptyRows remain effectively undocumented.

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

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

States a specific verb and resource ('Runs a custom report query against GA4 data'), and the word 'custom' implies ad-hoc dimensions/metrics rather than a canned or realtime report. However, it never names siblings like ga4_run_realtime_report or ga4_run_funnel_report, so differentiation is implicit rather than explicit.

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 exists: the description does not mention when custom reporting is appropriate, when to prefer ga4_run_realtime_report for fresher data, or when ga4_traffic_overview would suffice. An agent facing eleven GA4 siblings gets no routing signal from this 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool 'gets' an overview, implying a read-only operation, but it does not disclose the output format, whether the response is aggregated or row-level, pagination behavior, data limitations, or how the compareTo parameter affects the results. This is a significant gap for a tool with no annotation support.

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, front-loaded with the verb and resource, and contains no filler or redundant phrasing. It is easy to parse, though its brevity underspecifies important behavior and parameter semantics.

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 schema gives the agent the required propertyId and dateRange, but there is no output schema and no annotations. The vague 'comprehensive traffic overview' scope and the undocumented compareTo parameter leave an agent uncertain about what the tool returns and when to choose it over sibling GA4 reporting tools, making confident invocation difficult.

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 description adds no parameter-level information. The schema describes propertyId and the inner startDate/endDate fields, but compareTo has no description and dateRange as a whole is not described. With schema_description_coverage low, the description should compensate, but it mentions none of the parameters, leaving the meaning and usage of compareTo especially unclear.

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 a specific verb ('Gets') and resource ('comprehensive traffic overview') and lists the included dimensions: sources, pages, devices, and geography. It is easy to understand the tool's scope, but it does not explicitly compare itself to sibling GA4 report tools like ga4_run_report or ga4_run_funnel_report, leaving differentiation 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 description provides no guidance on when to use this tool versus alternatives such as ga4_run_report, ga4_run_realtime_report, or ga4_run_funnel_report. There are no exclusions, prerequisites, or recommended scenarios. The only hint is the tool name itself, which is not sufficient for an agent to decide between similar reporting 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?

With no annotations provided, the description carries the full burden of behavioral disclosure and it only reveals that the operation creates something. It does not mention side effects, Google Business Profile post limits, topic-type-specific payload behavior, or permission requirements. For a mutation tool with zero annotation coverage, this is a substantial gap.

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 single sentence is front-loaded and contains no filler, which is good for scannability. However, it is undersized for a tool whose payload schema is deeply nested, so the brevity reads as under-specification rather than disciplined conciseness.

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 complex, with four topicType values that conditionally require event, offer, or callToAction blocks plus nested date and time objects, and there is no output schema or annotations to compensate. The description explains none of these interactions, so an agent must reverse-engineer the nested schema to build a valid post. This is adequate only for the simplest standard posts.

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 only 50% at the top level, and the large nested post object has no description, while the tool description adds no parameter semantics beyond the phrase GBP location, which duplicates the schema's Location resource name. The conditional meaning of topicType, which nested blocks apply to each value, is left undocumented by both the schema and the description.

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

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

The description states a specific verb (Creates) and a specific resource (a new post on a GBP location), so an agent can identify this as a write operation. It does not explicitly name sibling tools, but the create verb inherently distinguishes it from read/list siblings like gbp_list_posts and gbp_get_location. A clear but not maximally differentiated definition.

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

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

There is no guidance on when to choose this tool over gbp_list_posts or gbp_update_location, and no mention of prerequisites such as obtaining a valid location parent from gbp_list_locations. The only usage signal is the verb Creates, which restates the tool's purpose. Routing and precondition discovery are left entirely to the agent.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure, yet it only restates the mutation. It does not warn that deletion is permanent, explain that the review itself remains intact, or note any required permissions. For a destructive tool this is a significant gap.

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 six-word sentence, front-loaded with the verb and object, with no fluff. Every word earns its place and the structure is immediately 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?

The tool has only one parameter and no output schema, so the description is close to sufficient. However, it lacks usage prerequisites and any behavioral warning for an irreversible action, leaving an agent to infer important context from sibling names.

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 parameter already specifies 'Full review resource name'. The tool description adds no additional meaning about how to obtain that name or whether it refers to the review or the reply resource, so it is neither harmful nor additive.

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 ('Deletes') and a specific resource ('a reply to a review'), which clearly distinguishes it from sibling tools like gbp_reply_review for creating/updating a reply and gbp_list_reviews for reading reviews. An agent can understand the exact operation from this line alone.

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

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

There is no guidance about when to use this tool instead of gbp_reply_review or whether it should be used after listing reviews. The sibling list implies the context, but the description does not state any usage conditions, prerequisites, or exclusions.

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

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

The verb 'Gets' implies a read-only operation, which is useful, and there are no annotations to contradict or extend that. However, the description does not explain authentication needs, default date ranges, limitations, or what happens when metrics or time windows are omitted, leaving some behavioral uncertainty.

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 with no wasted words and the core purpose is front-loaded. It is concise, though it sacrifices useful detail in favor of brevity.

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 low schema coverage, no output schema, no annotations, and a likely overlapping sibling 'gbp_performance_report', the description is not sufficient for an agent to confidently select and invoke the tool. It lacks guidance on parameter values, format, and tool differentiation.

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 only 25%, with only 'name' documented. The description adds almost nothing about the three undocumented parameters: 'metrics', 'startTime', and 'endTime'. It does not explain what metric values represent, the expected time format, or that these fields are optional.

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 a verb ('Gets'), a resource ('performance insights'), and a scope ('a GBP location'). It is easy to understand what the tool does, but it does not distinguish itself from the closely named sibling 'gbp_performance_report', which appears to cover similar functionality.

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 alternatives like 'gbp_performance_report'. There is no mention of prerequisites, date-range conventions, or how it differs from other GBP tools, so an agent has to guess.

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

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

With no annotations and no output schema, the description carries the full burden of behavioral disclosure. It communicates that this is a read operation ('Gets'), but it does not say what 'detailed information' actually includes, whether authentication is required, what happens for invalid names, or what the response shape 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?

The description is a single short sentence with no redundant phrases or unnecessary details. It is appropriately sized for a one-parameter retrieval tool and is easy to parse quickly.

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?

Although the parameter is well documented, there is no output schema and the description does not define what 'detailed information' returns. An agent would not know which location fields to expect or whether the tool is suitable for a specific data need. Low complexity helps, but the missing return-value description is a real gap.

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

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

Schema description coverage is 100%, so the schema already fully documents the only parameter `name` including its required format. The description adds only the word 'specific' and does not provide additional meaning beyond what the schema offers.

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 operation ('Gets detailed information') and the resource ('a specific GBP location'), and the word 'specific' helps distinguish it from listing tools like gbp_list_locations. It does not explicitly compare against sibling tools, but the verb+resource combination is unambiguous.

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

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

Usage context is only implied: the tool is for retrieving one specific GBP location rather than listing many. There is no explicit guidance on when to prefer this tool over gbp_list_locations or other location-related siblings, and no exclusion 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?

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that only accounts accessible to the authenticated user are returned, which is useful, but it omits pagination behavior despite the presence of pageSize and pageToken parameters. No mention is made of what the response contains or how to handle multiple pages.

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 filler. Every word contributes to the core meaning, making it highly efficient and easy to parse.

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 no output schema and no annotations, so the description must explain enough for an agent to invoke it and interpret results. It covers the basic purpose and auth scoping but leaves out pagination handling and the shape of the returned account list, which are important for a complete 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 description coverage is 0%, and the description adds no information about pageSize or pageToken. The parameter names are somewhat self-explanatory, but the description does not compensate for the lack of schema-level documentation, so the agent must guess at pagination 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 a specific verb ('Lists') and resource ('Google Business Profile accounts accessible to the authenticated user'), making it immediately clear what the tool does. It also distinguishes itself from sibling tools like gbp_list_locations and ga4_list_accounts by naming the product and resource exactly.

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—whenever a list of GBP accounts is needed—but provides no explicit guidance about alternatives or exclusions. It does not mention that location-level operations should go to gbp_list_locations, nor does it state a preference for when to call this tool first.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It signals a read-only operation but says nothing about pagination despite the pageToken/pageSize parameters, filter behavior, or response characteristics — and the phrase 'all locations' slightly over-promises given paginated results.

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

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

A single front-loaded sentence with zero filler — the verb comes first and the scope is stated compactly. It is appropriately lean, though it borders on under-specification, which is penalized in other dimensions.

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?

Despite being a relatively simple tool, the absence of annotations, an output schema, and parameter documentation means the description must carry more weight. Missing context includes filter syntax, pagination flow, and what fields each returned location contains, so an agent cannot fully anticipate the call or its result.

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

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

Schema description coverage is only 25% (only accountId is documented), and the description adds no parameter detail beyond what the schema already provides. The syntax of 'filter' and the meaning of 'pageToken' are entirely undocumented, so an agent cannot know how to construct valid filter strings or complete a multi-page iteration.

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 ('Lists'), resource ('locations/businesses'), and scope ('for a GBP account'), which clearly distinguishes it from sibling tools like gbp_get_location (single location) and gbp_list_reviews (reviews, not locations). It is clear and unambiguous about the tool's fundamental operation.

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

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

Usage is implied by the verb 'Lists' — an agent can infer this is for enumerating a GBP account's locations, likely to obtain IDs for downstream tools like gbp_get_location or gbp_update_location. However, there is no explicit when-to-use vs when-not-to-use guidance, and no alternative tools are named.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that media items are listed and provides no information about pagination, authentication, ordering, filtering, or what happens when the parent location is invalid.

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 focused sentence with no filler. The verb and primary object are front-loaded, making it easy to scan and understand.

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 relatively simple, and the parameter names (parent, pageSize, pageToken) are somewhat self-explanatory. However, with no annotations, no output schema, and only 33% schema coverage, the description leaves pagination behavior and return format to inference.

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 only 33%, with pageSize and pageToken lacking descriptions in the schema. The description adds minimal context for parent ('for a GBP location') but does not compensate for the undocumented parameters or clarify their expected values.

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 ('Lists'), the resource ('media items'), the content type ('photos, videos'), and the scope ('for a GBP location'). It is clear and distinguishes this from related tools like gbp_list_posts, though it does not explicitly name the sibling it is not.

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 on when to use this tool versus alternatives such as gbp_list_posts or gbp_upload_media. There is no mention of prerequisites, exclusions, or context that would help an agent decide between similar GBP 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and does not mention pagination, ordering, authentication needs, or that the operation is read-only. For a listing tool this is minimally informative but still lacks behavioral context beyond the verb itself.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the tool's core action and 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 no annotations, no output schema, and an incomplete parameter schema, the one-sentence description leaves too much unspecified: return value shape, pagination behavior, page size limits, and how the parent location resource name is obtained. It is minimally usable but not complete for an agent selecting and 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?

Schema description coverage is only 33%, with pageSize and pageToken left undocumented in both the schema and description. The description adds only that the parent is a GBP location, which the schema already states, and provides no meaning for the pagination parameters.

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') plus a clear resource ('posts') scoped to a GBP location. It is immediately distinguishable from sibling tools like gbp_create_post, gbp_list_reviews, and gbp_list_media.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no explicit read-only framing. Some usage can be inferred from 'Lists posts,' but the description never states a selection condition or contrasts with related GBP 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?

With no annotations provided, the description carries the full behavioral disclosure burden, and only the verb 'Lists' implies a non-destructive read. It does not disclose pagination behavior, default ordering, which review fields are returned, or authorization prerequisites, all of which matter for a 4-param list 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 six-word sentence with the verb front-loaded and zero filler. It is appropriately compact, though its brevity reflects under-specification more than deliberate pruning of 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?

For a tool with no annotations and no output schema, the one-liner is insufficient: an agent cannot tell what review fields are returned, the default sort order, how to paginate past 50 reviews, or when to prefer this over gbp_list_posts. The orderBy enum hints at sorting, but the description never connects its behavior to the parameters.

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

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

Schema description coverage is only 25% (just 'parent' is documented), so the description needed to compensate for orderBy, pageSize, and pageToken, but it adds nothing. It only restates that the target is a location, which the schema already conveys for parent.

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 ('Lists'), a distinct resource ('reviews'), and a scope ('a GBP location'), which cleanly separates it from siblings like gbp_list_posts and gbp_reply_review. It is unambiguous about what the tool does, though sibling differentiation relies on the resource noun alone rather than explicit contrast.

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

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

There is no guidance on when to use this tool versus gbp_list_posts, gbp_get_insights, or other read tools for the same location. No preconditions (e.g., location ownership, verified business), exclusions, or alternatives are mentioned anywhere in the 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It states only that a report is 'generated' — it does not clarify that this is a read-only analytics operation, what metrics the report contains, how far back data extends, or whether generation is immediate or time-consuming. The vague word 'comprehensive' adds no concrete behavioral detail.

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 efficient sentence with no wasted words, which is structurally sound. However, the qualifier 'comprehensive' is filler that provides no real information, and the brevity comes at the cost of missing usage and behavioral 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?

With no output schema and no annotations, the description is the only source of context, yet it does not explain what the report covers, how it relates to gbp_get_insights, or how the locationName parameter should be formatted. For a two-parameter tool with a nested object, this one-liner leaves critical gaps an agent would need to resolve before calling 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?