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

There are no annotations, so the description bears full responsibility for disclosing behavior. It only mentions the audience_id format; it does not state whether archiving is reversible, what side effects occur (e.g., affects reporting), or required permissions. This leaves significant 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, front-loaded sentence that efficiently conveys the action and a key parameter clarification. Every word adds value, and there is no redundancy.

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

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

With no annotations, no output schema, and an incomplete parameter description (property_id unspecified), the description lacks essential context for a mutation tool. It does not explain the consequences of archiving or what happens after the call, leaving the agent under-informed.

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 descriptions are absent (0% coverage), but the description adds valuable detail for audience_id, noting it may be a numeric id or full resource name. However, property_id is left entirely undefined, so the compensation is only partial for a two-parameter tool.

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

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

The description clearly states the action ('Archive') and the resource ('GA4 audience'), making the tool's purpose unambiguous. It also distinguishes from siblings like list_audiences and create_event_audience by using a distinct verb and target.

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

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

The description conveys a clear use case: when you need to archive an audience. It doesn't explicitly mention alternatives or exclusions, but no competing sibling exists (archive_custom_dimension is for a different resource). Thus, the context is clear enough without explicit 'when-to-use' guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Archive (delete)', which indicates a destructive operation, but does not mention whether the action is reversible, what side effects occur (e.g., on reports or metrics), or any permission requirements. This is a significant gap for a deletion 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 sentence with no redundant wording. It front-loads the action and immediately addresses a likely parameter confusion. This is appropriately concise for a simple 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 two-parameter destructive tool with no output schema and no annotations, the description provides the core action and an important parameter detail, but it omits consequences (e.g., permanence, permission needs) and return behavior. It is minimally complete but leaves the agent guessing about the full impact.

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 useful semantics for custom_dimension_id by clarifying it can be a numeric id or full resource name, which is beyond the bare schema. However, property_id lacks any explanation, and with 0% schema description coverage, the description only partially compensates for the two 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 clearly states the action 'Archive (delete)' and the resource 'custom dimension', making the tool's purpose obvious. It does not explicitly differentiate from sibling tools like archive_audience, but the resource specificity is sufficient. A score of 5 would require explicit mention of alternatives or scope exclusions.

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, nor does it list any prerequisites or exclusions. Usage is only implied by the action itself, which is insufficient for a tool with many siblings like create_custom_dimension and list_custom_dimensions.

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 bear the full transparency burden. It discloses validation rules (scope values, display_name charset) but not return behavior, idempotency, or propagation delays. The verb 'Create' makes the mutating nature obvious, avoiding contradiction.

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

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

Two concise sentences, front-loaded with the action, every clause adds operational detail. No redundant filler or unnecessary commentary.

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

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

For a 5-parameter create operation with no annotations or output schema, the description is too thin. It fails to explain the required property_id, return/response behavior, or how the created dimension appears in list_custom_dimensions. This leaves the agent to infer important invocation 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 has 0% description coverage, so the description must compensate. It explains parameter_name and scope values, and display_name constraints, but omits property_id (a required parameter) and description. This is useful but incomplete.

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 specific action 'Create' and resource 'custom dimension', making it clear it creates a GA4 custom dimension. It also distinguishes from siblings like list_custom_dimensions, archive_custom_dimension, and create_custom_metric.

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 create_custom_metric, or how it relates to archive_custom_dimension. No prerequisites or decision context are provided beyond the action itself.

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

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

With no annotations provided, the description carries the full responsibility for behavioral disclosure. It only states the creation action and enum values, without explaining side effects, required permissions, idempotency, or what the result of creation entails. This is a significant gap for a mutation 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 concise, consisting of two short sentences, with no wasted words. The measurement_unit enumeration is a useful addition, though the structure could be improved by including required parameters or usage context.

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

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

The tool has six parameters with no schema descriptions, no annotations, and no output schema. The description covers only the creation action and one parameter's enum values, leaving the purpose and semantics of the other parameters and the operational behavior unexplained. This is insufficient for effective tool selection and 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?

The description adds meaningful enumeration for the measurement_unit parameter, which is absent from the schema. However, the other five parameters (scope, description, property_id, display_name, parameter_name) receive no semantic explanation, and schema description coverage is 0%, so the description only partially compensates.

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

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

The description clearly states the action 'Create' and the resource 'a custom metric', which is specific and distinguishes it from sibling tools like create_custom_dimension or list_custom_metrics. The verb+resource construction 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?

The description provides no guidance on when to use this tool versus alternatives such as create_custom_dimension or list_custom_metrics. There is no mention of prerequisites, exclusions, or alternative tools for different scenarios.

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 disclose behavioral details itself. It only mentions membership duration and its maximum, but omits side effects such as whether duplicate names are allowed, permission requirements, reversibility, or what the response contains. This leaves significant behavioral uncertainty for a create 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 two sentences, front-loaded with the core purpose, and includes a concrete use case and a key parameter constraint without extraneous words. Every sentence adds value, making it highly efficient.

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

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

The tool has 5 parameters, no annotations, and no output schema, so the description must cover more ground. It explains the business use case and one parameter detail, but does not describe required parameters beyond examples, nor return values or error conditions. It is minimally viable but leaves notable 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?

The description adds meaning for two parameters: event_name via concrete examples and membership_duration_days via the max 540 constraint. However, the other three parameters (property_id, display_name, description) remain unexplained beyond the schema, and schema coverage is reported at 0%, so the description only partially compensates.

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

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

The description clearly states the tool creates a GA4 audience based on an event trigger, with specific examples ('purchase', 'generate_lead'). It differentiates from sibling tools like list_audiences or archive_audience by describing the creation action and its purpose for remarketing to Google Ads.

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 clear context on when to use it ('useful for remarketing lists that can be shared to Google Ads'). While it does not explicitly list exclusions or alternatives, no other sibling tool offers audience creation, so the guidance is adequate for the available toolset.

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 mentions valid counting_method values, but does not describe side effects, permission requirements, idempotency, error behavior, or what happens if the event is already a key event.

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

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

The description is a single sentence that front-loads the purpose and includes essential parameter information. No redundant words or filler, making it highly concise and well-structured.

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

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

For a simple create operation with no output schema, the description covers the core action and a key parameter, but omits details like return value, error handling, and permissions. Additional context would be beneficial for complete understanding.

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

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

Schema coverage is 0%, and the description adds value by enumerating allowed values for counting_method. The other parameters (property_id, event_name) are self-explanatory from their names and required status, but no additional semantics are given for them.

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

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

The description clearly states the action ('Mark an event as a key event') and the resource ('key event'), with 'conversion' providing context. It distinguishes itself from sibling tools like list_key_events by indicating a creation/marking 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?

The description implies use for marking conversion events, but does not explicitly state when to use this tool versus alternatives, nor any exclusions or prerequisites. The 'conversion' hint gives some context, but lacks clear 'use when' guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states that the tool returns a secret_value (api_secret) and warns to treat it as sensitive. This adds value beyond the basic create action, though it doesn't discuss other side effects or permissions.

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

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

The description is two sentences, front-loaded with the primary action, and includes essential return-value and security notes. Every word earns its place with no redundancy.

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

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

The description covers the core purpose, return value, and sensitivity, but lacks parameter explanations and return format details beyond the secret_value field. Given no output schema and no annotations, it is only partially complete for a create operation with three required 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?

The input schema has 3 parameters with 0% description coverage, so the description must compensate. It does not explain what property_id, stream_id, or display_name mean, nor their relationships. The phrase 'on a data stream' indirectly relates to stream_id, but no concrete parameter guidance is given.

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 ('Create a Measurement Protocol API secret on a data stream') with a specific verb and resource, and distinguishes this from sibling tools like list_measurement_protocol_secrets and delete_measurement_protocol_secret. It also mentions the connection to send_ga4_event, further clarifying its unique role.

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 use case: creating a secret needed by send_ga4_event. It provides context about when to use it (before sending GA4 events) but does not explicitly mention alternatives or when not to use it. The mention of send_ga4_event gives practical usage guidance beyond just 'create'.

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 disclosing behavioral traits. It only states 'Delete' and mentions secret_id formats, but does not mention irreversibility, required permissions, or side effects. This is minimal transparency 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 two sentences with no fluff. It includes the essential action and a valuable detail about secret_id, earning every word.

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

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

The tool is simple (3 required parameters, no output schema), and the description covers the basic action. However, it lacks explicit statements about the destructive nature and any prerequisites, making it minimally viable rather than complete.

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

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

Schema description coverage is 0%, so the description must compensate. It provides some meaning for secret_id (numeric id or full resource name) but leaves property_id and stream_id completely unexplained. This is partial compensation, insufficient for a 3-parameter tool.

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

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

The description clearly states the action: 'Delete a Measurement Protocol API secret.' This uses a specific verb and resource, and distinguishes it from sibling tools like list and create. The additional note about secret_id formats further clarifies the target.

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

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

No guidance is provided on when to use this tool versus alternatives, nor are any prerequisites or context given. The description only states what it does, not when to invoke it.

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

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

With no annotations provided, the description carries the full burden. It transparently lists the returned fields, which is a behavioral disclosure, and 'Get' implies a safe read operation. However, it does not mention error behavior, permissions, or any limitations, leaving some behavioral traits 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?

The description is one concise sentence, front-loaded with the action and resource, then a parenthetical list of fields. Every word earns its place with no filler or redundancy.

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

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

For a simple get operation with one parameter and no output schema, the description adequately covers the purpose and return contents. It lacks some edge-case details like property_id format or error handling, but the core information is present and understandable in context.

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

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

Schema description coverage is 0%, so the description must compensate. It tells the parameter is the identifier for 'one GA4 property', adding meaning beyond the raw name 'property_id'. However, it does not specify the format or provide examples, leaving some ambiguity for the agent.

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' with a clear resource 'configuration details for one GA4 property' and enumerates the included fields (name, time zone, currency, industry, create time). This distinguishes it from siblings like list_data_streams or list_account_summaries, which target different resources or scopes.

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 you need configuration details for a single GA4 property, but it does not explicitly state when not to use it or mention alternatives. Sibling tools like list_data_streams and run_report serve different purposes, so the guidance is implicit rather than explicit.

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

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

The description clarifies that tag_json must be the full GTM Tag resource, which is useful behavioral context. However, it does not disclose any other behavioral traits such as return values, validation errors, idempotency, required GTM permissions, or rate limits. With no annotations, the description carries the full burden and is under-informative.

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, with one sentence for the action and one for the parameter example. All content is relevant, no fluff.

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 gives a helpful example of the primary parameter, making the resource shape concrete. But it does not mention return values, error handling, or any prerequisites, leaving the agent without a complete picture for a mutation tool with no annotations and no output schema.

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

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

The description explains the complex tag_json parameter with a concrete example, which is valuable. However, it provides no additional meaning for account_id, container_id, and workspace_id beyond their schema titles, and schema coverage is 0%. The IDs are self-explanatory but the description could have at least specified their roles.

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 ('Create a tag') and the resource (tag). It distinguishes from sibling tools like create_trigger and create_variable by naming the specific resource. The example further reinforces the 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 explicit guidance is provided about when to use this tool versus alternatives, nor any prerequisites or after-effects. The context implies creation, but there is no discussion of required prior setup (e.g., account/container/workspace IDs) or when to prefer this over gtm_update_tag.

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 must fully disclose behavioral traits. It adds some useful context by specifying that the input must be a 'full GTM Trigger resource (JSON string)', implying a complete object rather than partial fields. However, it does not mention whether the operation is idempotent, what permissions are required, what the response contains, or what happens on validation failure. For a mutation tool, 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?

The description is a single sentence that front-loads the verb and resource, and includes the key qualifier about the JSON input. There is no redundant wording or filler.

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

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

Given that this is a create operation with no annotations, no output schema, and four required parameters, the description is too minimal. It does not explain the expected structure of the trigger JSON, whether the created trigger is returned as a response, or how the tool integrates with GTM workspaces and containers. Users would need external documentation to use it effectively.

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

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

The schema provides zero coverage for the four parameters. The description adds meaning only to trigger_json by clarifying it must be a full trigger resource, but account_id, container_id, and workspace_id remain undefined. While these IDs are self-explanatory by name, the description does not compensate for the low schema coverage overall.

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 ('Create') and resource ('trigger'), and clearly distinguishes the input format ('full GTM Trigger resource (JSON string)') from siblings like gtm_update_trigger or gtm_create_tag. It leaves no ambiguity about the tool's 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 this tool versus alternatives. It does not mention prerequisites (e.g., an existing workspace) or state that this is the correct tool for creating a new trigger as opposed to updating an existing one. With many similar create tools among siblings, this lack of context is a notable gap.

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, and the description discloses no behavioral traits beyond the basic action. It does not mention idempotency, side effects, required permissions, or error behavior, leaving the agent with no additional context about the operation's consequences.

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 redundant words, making it highly concise and front-loaded.

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

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

For a tool with four required parameters and no annotations or output schema, the description is too sparse. It lacks any context about the expected JSON structure, return value, or prerequisites, making it insufficient for an agent to use 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?

The description clarifies that variable_json is a full GTM Variable resource, adding meaning beyond the schema's bare property name. However, it does not explain the purpose of account_id, container_id, or workspace_id, though these are somewhat self-explanatory from their 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 uses a specific verb ('Create') and resource ('GTM Variable') and specifies the input as a 'full GTM Variable resource (JSON string)', clearly distinguishing it from sibling tools like gtm_update_variable or gtm_create_tag.

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 usage guidance is provided regarding when to use this tool versus alternatives. The phrase 'from a full GTM Variable resource' implies a prerequisite but does not state when-not-to-use or name 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 full burden of behavioral disclosure. It discloses the key outputs (containerVersion, containerVersionId, compiler errors) and the critical non-publishing behavior. However, it does not mention permissions, reversibility, or what happens to the workspace after freezing, which would add depth. Still, the most important behavioral traits are covered.

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

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

The description is two sentences, front-loaded with the main purpose, then returns value and a critical exclusion. There is zero wasted wording; every sentence earns its place.

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

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

The description explains the return value (including containerVersionId and compiler errors) despite lacking an output schema. It also covers the non-publishing aspect and next steps. However, it does not explain parameter semantics or edge cases (e.g., prerequisites, notes field), leaving some gaps for a 5-parameter tool with 0% schema coverage.

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 provides no additional information about the parameters (name, notes, account_id, container_id, workspace_id). The parameter names are self-explanatory to some degree, but the description does not add meaning beyond the schema, which is a significant gap given the lack of 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 clearly states the action ('Freeze the current workspace into a new container version'), identifies the resource (container version), and distinguishes it from the sibling tool gtm_publish_version by explicitly noting it does NOT publish. This is a specific verb+resource pairing with clear 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?

The description explicitly states when to use this tool (to freeze/version a workspace) and what to do next ('use gtm_publish_version next'). It also clarifies what it does not do ('This does NOT publish'), providing clear usage context and an explicit alternative.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds a key behavior by noting that confirm must be true, but it does not specify what happens when confirm is false, whether deletion is permanent, or any error 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 highly concise, using two short sentences to convey the purpose and a critical prerequisite. Every word earns its place, and it is front-loaded with the core action.

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 destructive operation with 5 parameters and no annotations or output schema, the description is inadequate. It omits the meaning of the ID parameters, the consequence of confirm=false, whether the action is reversible, and any success/failure response 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 0%, so the description must compensate. It only explains the confirm parameter (requires true) but provides no explanation for account_id, container_id, workspace_id, or tag_id, leaving their semantics to inference.

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 "Delete a tag" with a specific verb and resource, making it unambiguous. It distinguishes from sibling tools like gtm_create_tag and gtm_update_tag by focusing on deletion.

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 includes a specific usage requirement: "Requires confirm=true." However, it does not provide explicit when-to-use or when-not-to-use guidance, nor alternatives, leaving usage context mostly implied.

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

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

No annotations are provided, so the description carries the burden. It discloses the destructive nature ('Delete') and the confirm=true requirement, but does not mention permissions, irreversibility, or effects on dependent entities. The confirm requirement adds some value, but the description remains thin on behavioral context.

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

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

The description is two short sentences, front-loaded with the action, and contains no fluff. Every word earns its place, making it highly scannable.

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

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

For a destructive operation with no annotations and no output schema, the description is too sparse. It lacks information about consequences, prerequisites, and return behavior. While the confirm requirement is helpful, it is not enough to make the tool fully self-contained.

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. It only clarifies that confirm must be true, while the four required IDs (account_id, container_id, workspace_id, trigger_id) are left to their property names. This adds minimal meaning beyond the schema.

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

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

The description states the specific action and resource: 'Delete a trigger.' This clearly distinguishes it from sibling tools like gtm_delete_tag and gtm_delete_variable. 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 on when to use this tool versus alternatives, nor any mention of prerequisites such as obtaining trigger_id from gtm_list_triggers. There are no exclusions or alternative recommendations.

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 disclosing behavioral traits. It does add one key behavioral detail: the deletion only proceeds when confirm=true is passed. However, it does not explicitly state the irreversible nature of deletion, potential cascading effects, or any required permissions, leaving significant gaps.

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

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

The description is exceptionally concise, using two short sentences that deliver the core action and the critical confirmation requirement with no filler. Every word earns its place, and the key information is front-loaded.

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

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

Given the absence of annotations and output schema, the description is too sparse to be contextually complete. It does not explain the outcome of deletion, whether it is reversible, potential errors, or any side effects. The confirm requirement is helpful but insufficient for a destructive operation.

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 meaningful semantics for the confirm parameter by specifying it must be true, which is not evident from the schema's default of false. However, with 0% schema coverage, it fails to provide any guidance on the four ID parameters, though these are fairly self-explanatory from their 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 clearly states the action 'Delete' and the target 'variable', making the tool's purpose unambiguous. While it doesn't explicitly name alternative tools, the resource type in the description and tool name inherently distinguish it from sibling delete tools such as gtm_delete_tag and gtm_delete_trigger.

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 or any prerequisites beyond the confirm requirement. The phrase 'Requires confirm=true' is a usage constraint, not a contextual guideline. No mention of exclusions or scenarios is made.

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 fully disclose behavior. It only states the core operation and does not mention edge cases (e.g., no live version), return format, permissions, or side effects. This leaves significant behavioral ambiguity for a tool with no output schema.

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

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

The description is a single, concise sentence with no redundant information. 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?

Given the simple tool shape (2 required params, no output schema, no annotations), the description is incomplete. It provides no parameter semantics, no return description, and no usage guidance. The tool would be non-functional for an agent without external knowledge.

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 either parameter (account_id, container_id). The parameter names are self-explanatory, but the description adds no meaning beyond the raw schema, failing to compensate for the lack of 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 'Get' and clearly identifies the resource as the 'currently live (published) container version.' This distinguishes it from sibling tools like gtm_list_versions and gtm_publish_version, making the purpose unmistakable.

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 explicit guidance on when to use this tool versus alternatives such as gtm_list_versions. While the '(published)' qualifier implies a distinction, it does not state a clear use case or exclude other 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 must disclose behavioral traits. It does not state that this is a read-only operation, does not mention authentication requirements, error handling, or return value expectations. For a get operation, the read-only nature is somewhat evident, but the lack of any behavioral disclosure 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 concise sentence, with no wasted words. However, it is too sparse to be fully helpful. It is not overlong, but it omits essential context, so it earns a mid-range score rather than a higher one.

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 4 required parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain the need for account/container/workspace IDs, what the function returns, or any potential errors. This is inadequate for an agent to invoke the tool correctly.

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

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

Schema description coverage is 0%. The description mentions 'by id,' which provides minimal insight into the 'tag_id' parameter, but the other three required parameters (account_id, container_id, workspace_id) are completely unexplained. The description does not compensate for the lack of parameter information in the schema.

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

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

The description clearly states the action: 'Get a single tag by id.' It specifies the verb (Get), the resource (tag), and the scope (single vs. multiple), which distinguishes it from sibling tools like gtm_list_tags. However, it does not provide any additional context about the required IDs or the hierarchical structure.

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 offers no guidance on when to use this tool versus alternatives like gtm_list_tags. There is no mention of when not to use it, no prerequisites, and no reference to other tools. The usage context is only implied by the phrase 'single tag by id,' which is insufficient.

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 add a key constraint—'the service account can access'—which implies permissions scoping. However, it does not mention read-only nature, response structure, or error handling, though the simplicity of a 0-parameter list tool mitigates this 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, front-loaded sentence with no wasted words. It immediately states the action and scope, achieving maximum clarity in minimal space.

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

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

For a parameterless, simple list operation, the description conveys the essential function and scope. It assumes domain knowledge of what GTM accounts are, which is acceptable. The return format is not described, but for a simple list tool, this is a minor omission. Overall, it is sufficiently complete given the tool's simplicity.

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

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

The input schema has zero parameters, and the description correctly requires none. Since there are no parameters to document, the description does not need to add parameter-level semantics. The baseline of 4 applies because there are no parameters to explain.

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 'List,' names the resource 'GTM accounts,' and adds a precise scope ('the service account can access'). This clearly distinguishes it from a generic listing tool and matches its name. It effectively differentiates from the sibling 'list_account_summaries' by focusing on accounts rather than summaries.

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 like 'list_account_summaries.' It does not state exclusions, prerequisites, or typical use cases. While the purpose is clear, an agent receives no help in choosing between this and similar list-oriented 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 states the action and omits any information about response format, pagination, authentication, or side effects, even though listing is a read 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 sentence with no filler, front-loading the verb and resource. It is concise and well-structured.

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

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

The tool is simple (one parameter, no output schema), and the description covers the core purpose. However, it lacks details about return values, pagination, or any caveats, making it minimally viable but not fully complete for an agent invoking it.

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

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

Schema description coverage is 0%, and the description does not explain account_id beyond indicating it belongs to a GTM account. It adds minimal context about the parameter's meaning or format, leaving the schema to carry the required details.

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 ('List') and the resource ('containers') scoped to a GTM account, distinguishing it from sibling tools like gtm_list_accounts and gtm_list_workspaces.

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 use case (enumerate containers for a specific account) but does not explicitly mention when to prefer it over alternatives or any prerequisites beyond the required account_id. No exclusions or alternative tools are referenced.

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 'List tags' without mentioning pagination, ordering, return format, or explicitly confirming a read-only operation, offering no behavioral context beyond the action 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 six words, front-loaded with the verb and object, and contains no filler. It is concise and well-structured, with every word earning 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 simple list operation with three self-explanatory string IDs and no output schema, the description is minimally adequate. However, it lacks guidance on the required account/container/workspace hierarchy, response contents, and pagination, which would make it more complete.

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

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

Schema description coverage is 0% and the description adds no parameter-specific meaning beyond the word 'workspace', which maps only to workspace_id. The roles of account_id and container_id are left unexplained, despite all three being required.

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 specific verb 'List' and resource 'tags', and scopes to 'workspace', clearly distinguishing it from sibling tools like gtm_list_triggers or gtm_list_variables. The plural form also contrasts with gtm_get_tag, leaving no ambiguity about the 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?

No guidance is provided on when to use this tool versus alternatives such as gtm_list_triggers, gtm_list_variables, or gtm_get_tag. The description does not mention prerequisites, exclusions, or a preferred context, leaving the agent to 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?

With no annotations, the description carries the full burden. It merely states the action and scope but does not disclose any behavioral traits such as pagination, read-only nature, error conditions, or required permissions. As a simple list operation, the lack is moderate but still a 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, straightforward sentence with no unnecessary words. It is front-loaded and easy to parse, earning high marks for conciseness and structure.

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 is minimal and does not explain the required parameters or what the function returns. With no output schema, return values are not covered, and no usage context is given beyond the basic operation.

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 has three required parameters with no descriptions, and the tool description only mentions 'workspace,' providing no explanation for account_id or container_id. Since schema coverage is 0%, the description fails to compensate, leaving parameter meaning ambiguous.

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 ('List') and the resource ('triggers'), and scopes it to a workspace, which distinguishes it from sibling list tools like list_tags or list_variables.

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

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

No guidance is provided on when to use this tool versus alternatives like list_tags or list_variables. The description only states what it does without any context, exclusions, or alternative 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?

No annotations are provided, so the description must disclose behavioral traits. It only states a basic listing action, without mentioning return format, permissions, pagination, or read-only implications. The verb 'list' implies a read operation, but no explicit behavioral context is given.

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 that is appropriately sized for a simple listing operation. Every word contributes meaning with no filler.

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

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

Given the lack of annotations and output schema, the description is quite sparse. It does not explain what a variable is, what the response contains, or any operational context. For a three-parameter tool, this is insufficiently complete.

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

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

With 0% schema description coverage, the description must illuminate parameters. It mentions 'workspace' (aligning with workspace_id) but does not explain account_id or container_id, which are required. No additional meaning is added beyond the 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 'List variables in a workspace' clearly identifies the action (list) and the resource (variables) within a specific scope (workspace). This distinguishes it from sibling tools like gtm_list_tags and gtm_list_triggers, which target 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or typical contexts, leaving the agent without decision support.

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. It adds useful context that the tool returns only version headers (not full content) and covers both published and saved versions. However, it omits details such as pagination, authorization requirements, or return format.

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 of 9 words, front-loaded with the action and resource. No excessive detail or repetition.

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 2-parameter list tool with no output schema, the description is adequate but minimal. It tells what the tool lists but does not describe the returned object structure or any limits. Given the low complexity, it is marginally complete.

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

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

The schema coverage for parameter descriptions is 0%, and the description does not explain the parameters at all. The parameter names 'account_id' and 'container_id' are self-explanatory, but the description adds no semantic detail beyond the schema, failing to compensate for the lack of 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 the specific verb 'List' with the resource 'container version headers', and clarifies the scope 'published + saved versions'. This clearly distinguishes it from sibling tools like gtm_list_containers (lists containers) and gtm_get_live_version (gets the live version).

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 use case is implied by the 'List' verb, but there is no explicit guidance on when to use this tool versus alternatives like gtm_get_live_version or gtm_create_version. No exclusions or alternative tool names 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 burden. It only states 'List workspaces in a container' without disclosing behavioral details such as authentication requirements, pagination, sort order, or error behavior. It is neither misleading nor informative, but fails to add context beyond the name.

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, front-loading the purpose. However, it is extremely terse and lacks necessary details, though for the purpose of conciseness it scores well.

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 description must provide sufficient context for correct invocation. It fails to explain what a workspace is, how the parameters relate to the operation, or what the response contains, leaving the agent under-informed.

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 does not explain the meaning or format of the required account_id and container_id parameters. Schema coverage is 0%, so the agent receives no additional semantic information beyond the 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 uses the specific verb 'List' and identifies the resource 'workspaces' scoped to 'a container', clearly distinguishing it from sibling list tools like gtm_list_accounts or gtm_list_containers. It is concise and unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, nor any prerequisites or conditions for use. The description simply states the function without context or exclusions, leaving the agent to infer when this tool is appropriate.

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 transparency burden. It discloses the impactful nature of the action ('affects the live site') and the confirm requirement, which are critical behavioral details. It does not describe response format or reversibility, but the core warning is present.

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

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

Two sentences, front-loaded with the action, and no wasted words. The first sentence states the purpose, the second adds the critical requirement and rationale.

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 publish operation, the description covers the purpose and the key prerequisite. It omits details about return values or post-publish behavior, but with no output schema and a simple action, this is adequate.

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%. The description only clarifies the confirm parameter ('Requires confirm=true'), but provides no additional meaning for account_id, container_id, version_id, leaving those to rely solely on their names. This is insufficient compensation for a multi-parameter tool.

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

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

The description 'Publish a container version to live' specifies the action (publish), object (container version), and destination (live). This clearly distinguishes it from sibling tools like gtm_create_version and gtm_get_live_version.

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

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

The description states that confirm=true is required because publishing affects the live site, providing clear context on when to use this tool and the necessary invocation flag. It does not explicitly mention alternatives, but the purpose is unambiguous.

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

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

No annotations are provided, so the description carries the full burden. It discloses that an update uses a 'full GTM Tag resource', indicating a complete replacement rather than a partial patch. However, it lacks details on authentication, error cases, or side effects.

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-structured sentence that front-loads the action and resource. No redundant words, every part adds 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?

Given no output schema, no annotations, and five parameters with no schema descriptions, the description is too sparse. It does not mention return values, error behavior, or any prerequisites, leaving significant gaps for agent use.

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. It explains that 'tag_json' is a full GTM Tag resource, but does not clarify account_id, container_id, workspace_id, or tag_id beyond their names. With five params and only one explained, it falls short.

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 ('Update an existing tag') and the resource type ('full GTM Tag resource'). It distinguishes from sibling tools like gtm_create_tag and gtm_delete_tag by specifying 'existing' and the update verb.

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

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

It provides clear context that this tool is for updating an existing tag, which implies using it when a tag already exists and needs modification. It does not explicitly name alternatives or exclusions, but the 'existing' wording differentiates from create/delete operations.

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 must carry the burden of behavioral disclosure. It mentions 'full GTM Trigger resource', implying a complete overwrite rather than a partial update, which is a useful trait. However, it does not mention permissions, reversibility, side effects, or error conditions.

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 fluff. It immediately conveys the action and the input format, making it 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?

For a mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is sparse. It does not explain the return value, prerequisites, or what happens on success/failure. It gives only the core action and a hint about trigger_json, leaving the agent with insufficient context for robust 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%, so the description must compensate. It adds meaning to trigger_json by specifying it must be a 'full GTM Trigger resource', but does not elaborate on the four ID parameters. Their meanings are largely self-evident from names, but the description only partially compensates for the coverage gap.

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

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

Description clearly states the action 'Update an existing trigger' with a specific resource type, and defines the input as 'a full GTM Trigger resource (JSON string)'. This distinguishes it from sibling tools like create/delete/list triggers.

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 like gtm_create_trigger or gtm_delete_trigger. It does not state prerequisites, exclusions, or contextual cues for when an agent should invoke it.

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

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

With no annotations provided, the description carries the full burden. It discloses an important behavioral requirement: the need to provide a full resource, implying a complete replacement. However, it does not mention permissions, reversibility, or failure modes, leaving significant gaps for a mutation 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?

A single sentence with no redundant words, front-loaded with the action verb. It is concise and structured effectively.

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 5 required parameters, no annotations, and no output schema. The description provides only a minimal explanation of its purpose and the key payload requirement. It does not cover how to obtain IDs, the result or response, error cases, or the fact that this is a full replacement operation. Given the complexity, the description is insufficient.

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%. The description only hints that variable_json must be a full GTM Variable resource, but does not explain the purpose of the four ID parameters or how to construct the JSON. The parameter names are self-explanatory, but the description does not compensate for the lack of 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 states a specific action ('Update') with a clear resource ('existing variable') and specifies the required payload type ('full GTM Variable resource (JSON string)'). This clearly distinguishes it from sibling tools like gtm_create_variable and gtm_delete_variable.

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 for modifying an existing variable, but it does not explicitly state when to use it versus alternatives, nor does it mention prerequisites or exclusions. There is no reference to sibling tools or 'when not to use' guidance.

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

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

With no annotations, the description carries the burden. It conveys a read-only behavior ('Show', 'see') and discloses what it returns (identity, scopes, account count). It could explicitly note that it makes no changes, but the wording strongly implies 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?

The description is two sentences long, front-loaded with the purpose and followed by a use case. Every word contributes meaning, with no redundancy or fluff.

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 diagnostic tool, this is complete. It explains what it shows and why to use it. There is no output schema, but the description gives enough context by listing the outputs. A slightly more detailed return format would earn a 5.

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 baseline is 4. The description adds no parameter information, but none is needed. No additional semantics required.

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 tool shows the service-account identity, scopes, and account count for GTM. It uses the specific verb 'Show' and names a specific resource, distinguishing it from sibling tools like gtm_list_accounts.

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

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

The description explicitly says to use it to verify access after granting permissions, which is clear, practical guidance. It does not mention when not to use it or name alternatives, but the use case is strong.

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 transparency burden. It discloses the access scope ('the service account can see'), the exact return fields (account name/id, property display name and numeric id), and its role as a discovery step. It does not mention potential pagination or rate limits, but for a simple read-only list tool this is adequate.

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

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

Two concise, information-dense sentences. The first states the core function, the second details the return payload and usage guidance. No wasted words.

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

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

Given the tool's simplicity (0 params, output schema present), the description is fully complete. It covers what it returns, who can use it, and how it fits into the broader toolset.

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 a baseline of 4 is appropriate. The description adds no parameter details because none exist, and the schema already confirms the empty parameter set.

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 tool lists every GA4 account and its properties visible to the service account. It distinguishes itself from sibling tools by explicitly positioning it as the discovery entry point: 'Call this first to discover property ids for the other GA4 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?

Provides explicit when-to-use guidance: 'Call this first to discover property ids for the other GA4 tools.' This tells the agent this should be the initial discovery call before using the GA4 tools, effectively differentiating it from siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core action and does not mention read-only behavior, pagination, required permissions, or any other operational details beyond the literal listing.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently conveys the action and resource, making every word count.

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

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

The tool is simple with one parameter and an output schema, so a brief description is partially justified. However, it omits usage context and parameter clarification, which could lead to ambiguity among the many sibling list 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 0% and the description does not mention the property_id parameter at all. The description adds no meaning to help the agent construct valid arguments, leaving the parameter semantics entirely undefined.

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 'List' and identifies the resource as 'audiences defined on a GA4 property,' which clearly states the tool's function and distinguishes it from sibling tools like list_data_streams or list_custom_dimensions.

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 by naming the resource, but it does not provide explicit guidance on when to use this tool versus alternatives such as create_event_audience or archive_audience. No exclusions or alternative tools 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 bears the full burden. The verb 'List' clearly indicates a read-only operation, but it does not disclose whether archived dimensions are included, pagination behavior, or any required permissions. This leaves some behavioral aspects undefined.

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 words. It efficiently conveys the tool's core purpose in eight 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?

Given the low complexity (one parameter), the presence of an output schema, and no annotations, the description adequately covers the essential purpose and scope. However, it omits potential behavioral nuances like whether archived custom dimensions are returned, leaving minor ambiguity for the agent.

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. It clarifies that property_id refers to a GA4 property, adding context beyond the schema's bare 'Property Id', but it does not explain expected formats or additional constraints for 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 uses a specific verb ('List'), identifies the resource ('custom dimensions'), and scopes it to 'a GA4 property', distinguishing it from sibling tools like list_custom_metrics. This clearly conveys 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?

No explicit guidance is given on when to use this tool versus alternatives like list_custom_metrics or how it relates to create_custom_dimension and archive_custom_dimension. The purpose implies usage when retrieval of custom dimensions is needed, but this is not stated.

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

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

With no annotations, the description carries full burden, but it only states 'List custom metrics defined on a GA4 property.' It does not mention pagination, whether archived metrics are excluded, required permissions, or other behavioral 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, front-loaded sentence with no unnecessary words. It efficiently communicates the core purpose.

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

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

The tool is simple and has an output schema, so return values are covered. However, the description omits behavioral context like pagination and whether archived metrics are included, making it minimally complete.

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

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

Schema coverage is 0% and the description does not explain the property_id parameter beyond its name and the context of 'GA4 property.' The agent must infer the format and provenance of property_id.

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 (list) and resource (custom metrics on a GA4 property), distinguishing it from sibling tools like list_custom_dimensions or list_data_streams.

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

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

Usage is implied by the name and description, but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or preconditions.

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 action (list) and scope (web/app) but does not mention permissions, pagination, rate limits, or output format. The read-only nature is implied but not explicitly confirmed, and no safety characteristics are 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 two sentences: the first states the core functionality, the second provides a practical note about the stream id. Every sentence earns its place with no wasted words, and the structure is front-loaded.

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

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

The tool is simple, but the missing guidance on property_id format (e.g., 'properties/123' vs '123') and the lack of any safety annotations make it only partially complete. The downstream use case adds useful context, but a format example or explicit read-only hint would be needed for a higher 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?

The schema has one parameter, property_id, with no description at 0% coverage. The description does not mention property_id at all, leaving the agent to infer its meaning solely from the name. This is a significant gap that 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 clearly states the tool lists data streams (web/app) on a GA4 property, using the specific verb 'List' and resource 'data streams'. It distinguishes from siblings like list_measurement_protocol_secrets by explicitly noting the stream id's role, making its purpose unmistakable.

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 a stream id is needed for Measurement Protocol secret tools, providing clear context on when to use this tool. It does not explicitly compare with alternative list tools or state exclusions, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the function. No mention of whether results are paginated, filtered, or limited, nor any details about authentication, ordering, or side effects.

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 that communicates the core functionality with zero unnecessary words. It is appropriately sized for a simple list 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?

The description is minimally viable for a simple list operation, and an output schema exists to document return values. However, it lacks any context about when to use the tool vs. alternatives and does not elaborate on the required property_id parameter, leaving the agent with only the bare function statement.

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

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

Schema coverage is 0% and the parameter property_id has no description. The phrase 'on a GA4 property' hints that the parameter identifies the property, but it does not explain the expected format, how to obtain it, or whether it's a numeric ID or a string. The description adds minimal value beyond the schema.

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

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

The description clearly states the tool's function: listing key events (conversions) on a GA4 property. The verb 'list' and resource 'key events' are specific and distinguish it from sibling tools like create_key_event and 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?

No guidance is provided about when to use this tool versus alternatives. While sibling tools such as create_key_event imply complementary use, the description does not mention any exclusions, prerequisites, or alternative selection criteria.

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

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

No annotations are provided, so the description carries the burden of disclosure. The verb 'List' implies a read-only operation, and the note about stream_id being a numeric id from list_data_streams adds a useful constraint. However, it does not describe output behavior, potential errors, or whether secrets are returned in full.

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

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

The description is two sentences with no fluff: the first states the primary purpose, the second delivers a crucial parameter hint. 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?

The tool is a simple list operation with an output schema, so return values are covered externally. However, the description omits property_id explanation and does not mention when to use this versus create/delete. While adequate, it leaves gaps that could confuse an agent.

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. It explains stream_id (numeric id from list_data_streams) but leaves property_id entirely undocumented. This partial compensation is insufficient for two required 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 clearly states the tool lists Measurement Protocol API secrets for a data stream, using a specific verb and resource. It distinguishes itself from sibling tools like create_measurement_protocol_secret and delete_measurement_protocol_secret by focusing on listing.

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 actionable context by noting that stream_id comes from list_data_streams, establishing a prerequisite workflow. It implies this tool is for retrieving existing secrets but does not explicitly exclude create/delete 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 full burden. It discloses the time window and gives an example, but does not state that the operation is read-only, describe the return format, or mention pagination/error behavior. Some behavioral context is provided, but significant gaps remain.

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

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

Two sentences, front-loaded with the core action, and the example provides high value with no wasted words. Properly structured for quick scanning.

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 gives the essential purpose and an example, but without an output schema or annotations, it omits return value details and explicit guidance on when to prefer this over run_report. It is adequate but incomplete for a tool with four 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 0%, so the description must add meaning. It provides example values for metrics and dimensions, demonstrating array syntax and valid names. However, limit and property_id are not elaborated, relying solely on the schema titles for their purpose.

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 ('Run') and resource ('GA4 realtime report') with a time window ('last ~30 minutes'), clearly distinguishing it from the sibling tool run_report. The example further clarifies the intended use.

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 time window 'last ~30 minutes' clearly implies usage for recent data, but the description does not explicitly state when not to use it or name alternatives such as run_report for historical data. The context is clear, but exclusions are missing.

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 that metrics/dimensions use GA4 API names and that dates accept relative forms, which is useful. However, it does not disclose whether the operation is read-only, what the response format is, or any side effects, making the tool's behavior largely opaque.

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 well-structured: the first sentence states the purpose, and the second provides concrete parameter examples. It avoids filler and front-loads the most critical information, making it easy for an agent to quickly grasp the tool's function.

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, the description fails to cover essential context such as the response structure, pagination behavior, or any limitations. It also does not clarify the difference from 'run_realtime_report', leaving a gap in contextual understanding for tool selection.

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 important meaning for metrics, dimensions, and date formats by specifying GA4 API naming conventions and relative date syntax. However, it does not explain 'property_id' (beyond the schema title) or provide details about the 'limit' parameter. With 0% schema description coverage, the compensation is partial.

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 it runs a GA4 report with a specific verb and resource. It provides concrete examples of metrics and dimensions, clarifying the scope. However, it does not explicitly distinguish itself from the sibling tool 'run_realtime_report', so there is some ambiguity about whether this is for historical or realtime 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?

No explicit guidance is given on when to use this tool versus alternatives. The description implies it is for GA4 reporting but does not mention when to use 'run_realtime_report' or other sibling tools. There are no prerequisites, exclusions, or alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the validate=True behavior (hits debug endpoint, checks WITHOUT ingesting) and clarifies the source of api_secret and measurement_id. This goes beyond a simple 'send' statement, though it does not detail success/failure responses or permissions.

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 only two sentences long, front-loaded with the primary action. Every sentence earns its place: the first states the core behavior, the second adds essential validation guidance without verbosity.

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 send/action tool with no output schema and no annotations, the description covers the key workflow and parameter sources. It lacks a note on return values or errors, but for a fire-and-forget send operation, the guidance provided is largely sufficient. The unexplained event_name and params are minor 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 0%, so the description must compensate. It explains measurement_id, api_secret, client_id, and validate, but omits event_name and params. However, the explained parameters include format and source details (e.g., 'G-XXXXXXX', 'from a Measurement Protocol secret'), adding meaningful semantics beyond the schema.

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

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

The description clearly states the verb ('Send') and resource ('an event into a GA4 property') via the Measurement Protocol. It is specific enough to distinguish this tool from sibling tools, which focus on listings, reports, or GTM 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?

The description gives clear context for using the tool and provides practical guidance on the validate flag, recommending it for testing before real sends. It does not explicitly list alternatives or exclusions, but the context is sufficient given the uniqueness of the tool among siblings.

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