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

There are no annotations, so the description carries the behavioral burden. 'Get' clearly signals a read-only retrieval operation, and the property-id/measurement-id caveat adds useful operational context. Still, it does not mention error behavior, authentication needs, or what 'details' includes, leaving some behavioral ambiguity.

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

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

The description is a single, focused sentence with no redundant wording. The most critical clarification—the id type—is front-loaded, making it easy for an agent to parse and act on.

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

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

With no annotations, no output schema, and 0% parameter description coverage, the description is too sparse. It identifies the resource and the correct id format, which are essential, but it does not indicate return value shape, error conditions, or the purpose of the optional parameters, leaving a knowledgeable 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 description coverage is 0%, so the description must compensate. It adds important meaning to property_id by specifying that it is a numeric property id and not a measurement id. However, connection_id and session_token are left completely unexplained, and no additional parameter context is provided beyond the schema's bare titles.

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

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

The description uses a specific verb ('Get') and resource ('GA4 property's details'), and explicitly disambiguates property id from measurement id. This makes the tool's function clear and distinguishes it from sibling list/report tools.

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

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

The description implies when to use the tool: when you have a numeric GA4 property id and need the property's details. It also warns against using a measurement id. However, it does not explicitly mention alternatives or conditions for choosing another GA4 tool such as ga4_resolve or ga4_list_data_streams.

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 conveys that the operation is read-only and scoped to the authenticated user, which are useful behavioral cues in the absence of annotations. However, it does not disclose pagination, error behavior, or whether account and property summaries are returned together.

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

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

One sentence, front-loaded with the core action and resource, with no filler words. It is appropriately sized for the tool's simplicity.

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

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

For a simple read-only listing tool with only optional auth parameters, the description is nearly sufficient. It does not define return structure or pagination, but 'summaries' gives a reasonable expectation of what will be returned.

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

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

Both parameters lack schema descriptions (0% coverage), and the description never mentions connection_id or session_token. The parameter names are somewhat self-explanatory, but the description adds no meaning about how they are used.

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 (List), a specific resource (GA4 account/property summaries), and a scope qualifier ('accessible to the connected Google user'). This clearly differentiates it from the GTM siblings, which target a different Google product.

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

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

The description gives no guidance about when to call this tool versus alternatives such as ga4_get_property or gtm_list_accounts. The 'connected Google user' phrasing implies authentication context, but no exclusion criteria or fallback routing is provided.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'List data streams', implying a read operation, but does not state side effects, authentication needs, rate limits, or what the response looks like. Minimal disclosure for a tool with zero annotation coverage.

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

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

The description is a single concise sentence with no unnecessary words. It is appropriately sized for a simple list operation, though it lacks depth. No waste, but also no additional valuable information.

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

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

Given three parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what data streams are, how property_id relates to the GA4 hierarchy, or what information is returned. An agent would struggle to use this tool correctly without further 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%, meaning the description provides no parameter explanations. The schema alone defines property_id, connection_id, and session_token without any additional semantics. The description does not compensate for this gap, leaving agents to infer parameter meaning.

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

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

The description clearly states the action ('List') and the resource ('data streams') scoped to a GA4 property. It is specific enough to distinguish it from sibling tools like ga4_list_accounts or ga4_run_report, which operate on 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?

There is no guidance on when to use this tool versus alternatives. No context about prerequisites, typical use cases, or situations where this tool should be preferred over other listing tools is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does reveal the default behavior when measurement_id is omitted and describes the resolution transformation, but it does not state whether the operation is read-only, whether authentication is required, or what happens on failure.

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

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

The description is a single, focused sentence with no wasted words. It front-loads the core transformation and efficiently appends the default-value behavior.

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 annotations, no output schema, and three undocumented parameters, the description is too thin. It omits the purpose of the authentication/context parameters and does not specify the exact return structure beyond 'numeric property_id + stream', which is insufficient for reliable 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, but it only clarifies the measurement_id parameter and its default. The connection_id and session_token parameters are left entirely unexplained in both the schema and the description, leaving the agent to guess 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 uses a specific verb ('Resolve') and a defined resource ('GA4 measurement id'), and states the concrete output: numeric property_id + stream. The GA4 prefix and example clearly distinguish it from the sibling gtm_resolve tool.

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

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

The description implies the tool should be used when converting a GA4 measurement ID into a numeric property ID and stream. However, it does not explicitly state when to use it over alternatives like ga4_list_data_streams or ga4_get_property, and gives no exclusion criteria.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does well by warning about minutes-scale ingestion latency and explicitly stating that an empty result is not proof of data loss, which prevents a common misinterpretation. It does not cover output format, authentication, or quota behavior, but the most operationally important behavior is disclosed.

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

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

The description is compact and front-loaded: one direct statement of purpose, a minimal request-shape snippet, and a clearly separated IMPORTANT warning. Every sentence earns its place, and the pointer to docs/GA4-LATENCY.md is a useful escape hatch without bloating the description.

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

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

The description gives enough to invoke the tool correctly for the required parameters and warns about the most dangerous false-negative trap. But with no output schema, it does not describe what the response looks like, or clarify the optional connection_id and session_token parameters. It is adequate 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?

Schema description coverage is 0%, so the description must compensate. It adds essential meaning to the 'report' parameter by showing dimensions and metrics arrays with name fields, which is valuable given the schema treats it as a generic object. However, property_id, connection_id, and session_token receive no additional guidance, and the report shape itself is only partially illustrated with '...'.

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

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

The description clearly identifies a specific action and resource: 'Run a GA4 realtime report' and labels it 'read-only'. It also gives a compact request shape for the report object. It does not explicitly name ga4_run_report as the non-realtime alternative, so sibling differentiation relies on the 'realtime' term rather than an explicit contrast.

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

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

It provides an important usage caveat: realtime ingestion latency can produce empty results, and the agent should wait at least 5 minutes or calibrate with a canary before concluding events were dropped. However, it does not explicitly say when to choose this tool over ga4_run_report or when not to use it; the selection guidance is only implied by the word 'realtime'.

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 disclosure burden, but aside from 'read-only' it says nothing about auth requirements, how connection_id/session_token affect the call, error or empty-result behavior, page limits, or the response shape. This is a minimal safety hint, not adequate behavioral transparency for an API tool with optional auth parameters.

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 compact sentence that front-loads the action and then gives an inline shape for the key parameter. Every element earns its place.

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

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

For a 4-parameter tool with a nested open-ended report object and no output schema, this description is too thin. Missing date formats, dimension/metric field syntax, optional-parameter behavior, and any return-value guidance make it insufficient for confident 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 inline report = {dateRanges, dimensions, metrics, ...} adds real meaning to the otherwise opaque 'report' object schema. However, the other three parameters (property_id, connection_id, session_token) are not described at all, and the report field list is left open with '...'.

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

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

The description opens with a specific verb and resource ('Run a GA4 standard report') and adds 'read-only'. The word 'standard' distinguishes it from the sibling ga4_run_realtime_report without needing to open schemas.

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

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

It clearly frames the tool as the standard-report runner, implying it is the choice for ordinary GA4 reporting rather than realtime or administrative/list tools. It does not explicitly say when not to use it or name alternatives, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It describes what the tool does ('Create') and a naming expectation, but does not explain side effects, failure modes, required permissions, whether the tag is inserted immediately, or how to handle existing tags beyond avoiding duplication.

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

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

The description is short and front-loaded, stating the core action immediately. The second sentence adds a valuable guardrail against duplication. The acronym 'JPTB' is unexplained, which slightly reduces clarity, but overall there is no wasted text.

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

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

This is a creation tool with nested object parameters, no output schema, and no annotations, yet the description provides minimal operational context. An agent would not know how to build a valid tag object, what fields are required beyond the four IDs, or what response to expect. The description is too thin for the tool's complexity.

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 0% description coverage and the description adds no parameter-level meaning. It mentions 'full tag object' but does not explain account_id, container_id, workspace_id, connection_id, session_token, or the structure of the nested tag object. The agent must rely entirely on field names and external knowledge.

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 clear action and resource: 'Create a GTM tag (full tag object).' It also clarifies that the created tag should follow predictable JPTB naming, which signals the tool is for full object creation rather than partial edits. This distinguishes it from sibling tools like gtm_update_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?

The description gives explicit guidance to reuse or update an equivalent existing JPTB tag instead of duplicating, which tells the agent when not to create. It does not explicitly name alternatives such as gtm_list_tags or gtm_update_tag, but the intent is clear enough for routing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Create a GTM trigger', which implies mutation, but it does not explain side effects, required permissions, prerequisites like existing container/workspace, or what happens on failure. For a mutation tool with no annotation support, this is a significant gap.

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

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

The description is a single focused sentence with no filler words. The phrase '(full trigger object)' is concise and front-loads the key distinction about the trigger shape. 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 a complex nested trigger object, four required parameters, no output schema, and no annotations, the description is far too minimal. An agent has no information about the structure of the trigger object, how to obtain account/container/workspace IDs, or what the tool returns after creation. This is inadequate for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for parameter semantics, but it only adds the vague phrase 'full trigger object'. This gives minimal meaning to the 'trigger' parameter and nothing to account_id, container_id, workspace_id, connection_id, or session_token beyond their self-explanatory names. The nested trigger object's accepted fields remain completely undocumented.

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

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

The description states a clear verb ('Create') and resource ('GTM trigger'), and the parenthetical 'full trigger object' signals that the operation creates a complete trigger rather than a partial update. However, it does not explicitly differentiate itself from sibling tools like gtm_update_trigger or gtm_list_triggers aside from the verb 'Create'.

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 through the verb 'Create': use this tool when creating a new trigger rather than updating or listing triggers. It provides no explicit when/when-not guidance or mentions of alternative tools, but the intended context is recoverable from the tool name and sibling set.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It only implies write/mutation via 'Create' and offers no information about authentication, permissions, side effects, validation, duplicate handling, or response behavior.

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

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

The description is concise and free of filler, but it is under-specified for a tool with six parameters and a nested object. There is no structural break or additional detail that would make the short length feel sufficient.

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 tells the agent what action to take but not enough to invoke the tool correctly. Given no output schema, no annotations, a nested variable object, and zero schema description coverage, the single-sentence description leaves critical details about variable structure and required IDs unresolved.

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 essentially no parameter-level meaning. The 'variable' parameter is implied but not explained; account_id, container_id, workspace_id, connection_id, and session_token are all left undefined, with no guidance on their roles or formats.

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 names the resource ('GTM variable'), making the core operation clear. The parenthetical '(full variable object)' adds a small hint about the expected payload shape, though it does not explicitly differentiate this from gtm_update_variable or other create 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?

No guidance is provided about when to use this tool versus gtm_update_variable, gtm_list_variables, or the tag/trigger create tools. There is no mention of prerequisites, required context, or conditions that would steer an agent toward this tool.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one meaningful trait: the operation does NOT publish, preventing the agent from assuming creation implies deployment. But it omits other behaviors an agent would want to know — what the version contains (a snapshot of tags/triggers/variables), whether repeated calls create duplicate versions, auth/connection expectations, or what is returned.

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

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

A single sentence with zero filler: the verb and resource are front-loaded, the source is stated, and the critical non-publishing qualifier is tucked in as a high-value parenthetical. Every word earns its place.

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

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

For a 6-parameter tool with no annotations and no output schema, the description is adequate but thin. It establishes the core operation, yet leaves out the GTM workflow context (a version is a workspace snapshot and a prerequisite to publishing), response contents, and behavior on repeated calls. The sibling list partly compensates by revealing gtm_publish_version exists.

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

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

Schema description coverage is 0%, so the description must compensate for documenting the 6 parameters, but it barely does. 'from a workspace' adds a little meaning to workspace_id, and the tool name hints at 'name', yet account_id, container_id, connection_id, and session_token receive no explanation whatsoever. The description falls well short of carrying the parameter-documentation burden.

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

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

The description states a specific verb ('Create'), a precise resource ('GTM container version'), and the source ('from a workspace'). The parenthetical '(does NOT publish)' actively distinguishes it from the sibling gtm_publish_version, so an agent can tell them apart without opening either schema.

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

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

The explicit '(does NOT publish)' exclusion tells the agent when not to use this tool (when publishing is desired) and implies the publish workflow is handled elsewhere, with gtm_publish_version present in the sibling list. However, it never names the alternative explicitly or states a positive condition like 'use this to snapshot workspace changes before publishing.'

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

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

No annotations are present, so the description carries the full behavioral disclosure burden. It only says 'Get', implying a read operation, but does not mention auth requirements, response format, error behavior, or side effects. No contradiction exists, but the description adds little 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?

A single, front-loaded sentence with no filler. Every word adds meaning: 'single' scopes the operation, 'details' indicates the return, and 'GTM container' names the resource.

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

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

With no output schema and no annotations, the description is too thin: it omits return format, authentication context for connection_id/session_token, and error conditions. It is minimally viable for a simple call but not complete enough for an agent to invoke confidently in all cases.

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 needed to compensate by explaining the parameters, but it does not. account_id and container_id are inferable from the operation, yet connection_id and session_token are not explained, leaving their roles 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?

States a specific action (get) and resource (a single GTM container's details). The word 'single' distinguishes it from sibling listing tools like gtm_list_containers, and 'details' clarifies the return scope.

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 gtm_list_containers or gtm_get_version. The description implies it is for retrieving one container, but it does not state selection criteria, prerequisites, or exclusions.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only says 'Get' and 'full content' without explaining what that content includes, whether authentication or connection parameters are needed, or what the response structure looks like. This is a minimal disclosure for a tool with zero annotation support.

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

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

The description is a single focused sentence with no filler. It front-loads the core action and resource, making it easy for an agent to parse quickly.

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

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

The tool has no annotations and no output schema, so the description alone must support correct invocation. It fails to explain when to use this over gtm_list_versions, what 'full content' actually contains, or what the optional connection_id and session_token parameters are for. The description is adequate for recognizing the tool's purpose but not for fully guiding correct usage.

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-level meaning. While account_id, container_id, and version_id are fairly self-explanatory from their names, connection_id and session_token are not explained. The description does not compensate for the schema's lack of parameter documentation.

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

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

The description states a specific verb ('Get') and resource ('a single GTM container version's full content'), clearly distinguishing it from sibling tools like gtm_list_versions (which lists versions) and gtm_get_container (which gets a container, not a version). The meaning is immediately 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 word 'single' implies this tool is for retrieving one specific version rather than listing versions, and 'full content' suggests it provides more detail than a list. However, there is no explicit when-to-use or when-not-to-use guidance, nor any comparison to alternatives like gtm_list_versions.

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 convey that the operation is a read-only listing scoped to the connected user, but it omits any details about pagination, returned data shape, or authentication/authorization requirements beyond the implied user connection.

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 or redundancy. It is concise and easy to parse, though it sacrifices useful details that could have been included without harming brevity.

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

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

For a tool with no annotations, no output schema, and completely undocumented optional parameters, the description is too thin. It does not explain what the response contains, how connection_id or session_token behave, or what prerequisites exist. An agent is left with the bare purpose and no call-level guidance.

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

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

Schema description coverage is 0% and the description does not mention connection_id or session_token at all. An agent cannot infer what these parameters mean, whether they are needed, or how to populate them. The description adds zero meaning beyond the parameter names themselves.

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

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

The description uses a clear verb ('List') and specific resource ('GTM accounts'), and adds the scope 'accessible to the connected Google user.' This clearly distinguishes it from sibling tools like gtm_list_containers and gtm_list_tags, though it does not explicitly name them.

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

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

No guidance is provided about when to use this tool versus the many sibling list tools. It does not state that gtm_list_containers should be used for containers, or mention any selection or ordering logic among the list tools. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not mention authentication requirements, response shape, pagination, or any other behavioral details an agent would need.

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

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

The description is a single, front-loaded sentence with no filler or redundant content. It is concise and easy to parse, though the brevity comes at the cost of missing behavioral and contextual details.

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

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

With no output schema and no annotations, the description is not complete enough for an agent to understand return values or authentication expectations. It tells the agent this tool lists containers and requires account context, but leaves important operational details absent.

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 little to compensate. The phrase 'in a GTM account' gives some meaning to account_id, but the connection_id and session_token parameters remain entirely unexplained.

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

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

The description names a specific operation—listing containers—and scopes it to a GTM account, which is clear enough to distinguish it from tools like gtm_get_container or gtm_list_accounts. It does not explicitly differentiate itself from the other gtm_list_* tools, but the resource and verb are precise.

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

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

There is no guidance about when to use this tool versus gtm_get_container, gtm_list_workspaces, or other sibling tools. The description simply states what the tool does without providing context for choosing it or excluding 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 provided, the description carries the behavioral burden. 'Inspect-first' and 'do not touch unrelated tags' explicitly disclose non-destructive behavior. It does not cover pagination or return format, but for a simple list operation this is acceptable.

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

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

The description is a single tightly worded sentence that front-loads the action and resource, then adds a useful safety qualifier. There is no filler or redundant content.

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

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

The essential read-only behavior and GTM workspace context are clearly covered, and there is no output schema to elaborate on return values. Minor gaps include output shape and pagination, but these are not critical for selecting and invoking this list tool.

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

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

Schema description coverage is 0%, and the description adds no explanation for any of the five parameters. The parameter names are fairly self-descriptive and connection_id/session_token are likely auth-related, but the definition does not compensate for the missing schema descriptions.

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

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

The description states a specific action and resource: 'List tags in a GTM workspace'. This clearly distinguishes it from sibling tools that list triggers, variables, or workspaces, though it does not explicitly name those alternatives.

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

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

'Inspect-first; do not touch unrelated tags' clearly signals that this is a read-only inspection tool and advises against side effects. It does not explicitly name create/update alternatives, but the intended usage context is unambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'list triggers' and does not mention the return format, pagination, authentication/session requirements, or whether all triggers are returned. The verb 'list' implies a read operation, but that inference is left to the agent.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise for a simple list operation, though the brevity comes at the cost of missing behavioral and parameter detail.

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

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

For a tool with 5 parameters, no annotations, and no output schema, a one-sentence description is insufficient. It does not explain the GTM hierarchy, the purpose of the optional connection/session parameters, or what the returned trigger list contains. An agent would need external knowledge to use it correctly.

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

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

Schema description coverage is 0%, and the description provides no parameter-level meaning. The three required IDs (account_id, container_id, workspace_id) are not explained, and the ambiguous optional parameters connection_id and session_token are completely undocumented. The description adds no value beyond the raw schema titles.

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

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

The description states a specific verb ('List') and resource ('triggers') with a scope ('in a GTM workspace'), which clearly differentiates it from sibling list tools like gtm_list_tags, gtm_list_variables, or gtm_list_workspaces. It stops short of a 5 because it does not explicitly contrast with any sibling tool, but the purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus the many sibling list tools. The phrase 'in a GTM workspace' provides a scoping context but does not help an agent decide between gtm_list_tags, gtm_list_variables, gtm_list_versions, or gtm_list_triggers.

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. The verb 'List' implies a read-only operation, but nothing is disclosed about pagination, response shape, whether the listing is restricted to the specified workspace, or how deleted or uncommitted variables are treated. This is a gap rather than a contradiction since no annotations exist.

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

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

A single front-loaded sentence with no wasted words. It is efficiently concise, although its brevity contributes to gaps in behavioral and parameter coverage.

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 5 parameters, zero schema coverage, no annotations, and no output schema, a single sentence is insufficient. The agent learns only that variables are listed, but gets no parameter semantics, return structure, or behavioral details, while the large sibling set (~20 tools) creates meaningful selection pressure.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters but does not. Parameter names like account_id, container_id, and workspace_id are partially self-explanatory, yet connection_id and session_token remain unexplained, and no format or relationship details are given for any parameter.

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

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

The description states a specific verb ('List') and resource ('variables') scoped to a GTM workspace. The resource name distinguishes it from sibling list tools targeting accounts, containers, workspaces, tags, triggers, and versions, though no alternative is explicitly named.

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. There are no exclusions, no conditions, and no mention of sibling tools like gtm_list_tags or gtm_list_triggers, so the agent must infer usage solely from the resource name.

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

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

With no annotations, the description carries the full behavioral burden. It adds one genuinely useful trait — results include both published and draft versions — and 'List' implies a non-mutating read. But it says nothing about authentication expectations (connection_id/session_token), pagination, ordering, or what a 'version header' actually contains.

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

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

A single nine-word sentence that front-loads the verb and resource with no filler or restatement of the tool name. Every word earns its place, and brevity here does not harm clarity — the shortfalls are completeness issues, not conciseness issues.

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

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

There is no output schema and no annotations, so the description should supply more context. It covers what the tool does but omits invocation-level details: the two auth-adjacent parameters are undocumented and there is no pointer to gtm_get_version as the companion operation for full version detail. The tool is simple, but the definition leaves real gaps for the agent to bridge.

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, but it only implicitly anchors container_id (via 'GTM container') and account_id. connection_id and session_token are entirely unexplained in both the schema and the description, leaving the agent to guess their meaning, format, and necessity.

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

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

The description names a specific verb ('List'), a specific resource ('version headers' of a GTM container), and a useful scope qualifier ('published + drafts'). Within a sibling set that includes gtm_list_tags, gtm_list_workspaces, and gtm_get_version, this one is unambiguous: it is the list-versions operation, distinct from fetching a single 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 intended context is implied — you call this when you need version headers for a container identified by account_id and container_id. However, there is no explicit when-to-use guidance, no mention of gtm_get_version as the alternative for full version payloads, and no exclusions 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?

No annotations are provided, so the description must fully convey behavior. It only states 'List,' which implies a read-only retrieval operation, but it does not disclose pagination, ordering, return shape, authentication requirements, or 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 a single, focused sentence with no filler or redundant content. It is immediately readable and earns its place.

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

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

With no annotations, no output schema, and four parameters, the one-sentence description is incomplete. It does not explain what the response will contain, how connection/session parameters are used, or any limitations. For a simple list operation it is minimally usable, but significant context is missing.

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

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

Schema description coverage is 0% and the description does not explain account_id, container_id, connection_id, or session_token. It only implies that workspaces are scoped to a GTM container, leaving parameter semantics mostly to naming conventions.

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

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

The description uses a specific verb ('List') and identifies the exact resource ('workspaces in a GTM container'). This clearly distinguishes it from sibling tools that list accounts, containers, tags, triggers, variables, or versions.

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: use this tool to list workspaces within a GTM container. However, it provides no explicit guidance about when to choose it over alternatives or any exclusions, leaving the routing largely to inference from the tool name.

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

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

With no annotations provided, the description bears the full disclosure burden. It does warn that this is PRIVILEGED and requires user approval, which is meaningful behavioral context. However, it does not disclose that publishing pushes content to production, is likely irreversible, or what the consequences of the mutation are — for a privileged production action, more disclosure is expected.

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

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

Two short sentences with zero fluff, and the core purpose is front-loaded before the privilege warning. Efficient and scannable, though the sparseness borders on under-specification for such a consequential 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?

This is a privileged production mutation with no annotations, no output schema, and 5 params at 0% schema coverage — yet the description is only one clause plus a warning. Missing: irreversibility/consequences, the meaning of connection_id/session_token, prerequisites beyond 'prepared', and any return expectations. Given the tool's complexity and privilege level, this is materially incomplete.

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 nothing about any parameter. While account_id/container_id/version_id are self-explanatory, the optional connection_id and session_token are entirely opaque and undocumented in both schema and description. The description provides zero value beyond the schema field 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 states a specific verb and resource ('Publish a prepared GTM version to live') that clearly distinguishes it from siblings like gtm_create_version (which creates a draft) and gtm_get_version (which reads). The 'prepared' qualifier adds meaningful scope. Purpose is unambiguous and separable at a glance.

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

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

The 'only call after explicit user approval' gate is a real when-to-use constraint, but the description gives no guidance on how this tool differs from alternatives or when it should be chosen over gtm_create_version or the read-only list/get family. There is no exclusion statement or sibling reference, leaving the agent to infer positioning.

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 behavioral disclosure burden. It usefully discloses the default-to-configured-container behavior and the resolution output, but does not mention side effects, auth/session expectations, or error behavior. This is adequate but not rich.

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 tight sentence with a concrete example and a behaviorally important default. Every clause adds information, and there is no filler.

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

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

The tool is simple and the output mapping is provided despite no output schema. However, the role of connection_id and session_token is unexplained, and the lack of any exclusions or alternative routing leaves an agent to infer the full invocation 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 for undocumented parameters. It explains public_id by example and hints at optionality through the default behavior, but connection_id and session_token are entirely unaddressed, leaving the agent without enough meaning for two of three parameters.

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

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

The description uses a specific verb ('Resolve') and a clear resource ('GTM container publicId'), and explicitly states the output mapping (account_id/container_id/workspace_id). This distinguishes it from sibling tools like gtm_list_containers or ga4_resolve.

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

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

The description implies when to use the tool (when you have a GTM publicId or want the customer's configured container), and the default behavior is stated. It does not explicitly name alternative tools or exclusion criteria, so it stops 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 provided, the description carries the full burden of behavioral disclosure, but it only conveys that a tag will be updated. It does not explain whether this is a partial or full replacement, whether it requires a draft workspace, whether it affects published versions, or what happens if the tag does not exist.

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

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

The description is a single front-loaded sentence with no filler or redundancy. Every word is purposeful, achieving maximum conciseness while still identifying the operation and target.

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 7-parameter mutation tool with 5 required parameters, a nested object, no annotations, and no output schema, this description is severely incomplete. It does not explain the role of the id parameters, the structure of the tag object, or any behavioral implications, leaving the agent to guess.

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 almost no parameter meaning. The phrase 'by id' is ambiguous among the four id fields in the schema (account_id, container_id, workspace_id, tag_id), and the required nested 'tag' object is entirely undocumented.

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

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

The description states a specific verb ('Update'), a specific resource ('GTM tag'), and the targeting mechanism ('by id'). This clearly distinguishes it from siblings like gtm_create_tag, gtm_update_trigger, and gtm_update_variable, even without naming them.

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

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

No guidance is given on when to use this tool instead of alternatives such as gtm_create_tag or other update tools. The description neither states preconditions nor excludes scenarios, so the agent receives no routing or 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning whether the update replaces or merges the trigger object, whether permissions are required, what side effects occur, or how the API responds. This is a significant gap for a mutating 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 concise sentence with no filler or repetition. It front-loads the action and target, which is efficient, though it sacrifices useful 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?

This is a mutation tool with 7 parameters, no annotations, no output schema, and a nested free-form 'trigger' object. The one-sentence description provides only the basic intent and none of the context an agent needs to call it correctly: required scoping IDs, payload shape, side effects, or return behavior. It is inadequate for safe invocation.

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

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

Schema description coverage is 0%, and the description only clarifies that the update happens 'by id' (trigger_id). It does not explain account_id, container_id, workspace_id, or the 'trigger' payload object, which is a free-form nested object with additionalProperties. The parameter names are partially self-explanatory, but the main update payload is left completely 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 uses a specific verb ('Update') and resource ('existing GTM trigger by id'), clearly distinguishing it from creating a new trigger or updating other entity types like tags or variables. The phrase 'by id' also signals it targets an already-created trigger, which separates it from gtm_create_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 implies usage for updating an existing trigger rather than creating one, but it gives no explicit alternatives or conditions. It does not mention when to prefer gtm_create_trigger, gtm_update_tag, or gtm_update_variable, so the guidance is only implicit.

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

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

Annotations are absent, so the description must disclose side effects and mutation behavior. It only says 'Update', omitting whether the object replaces or patches the variable, what happens on invalid ids, authorization requirements, or downstream 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 sentence is short and front-loaded with no fluff. However, for a seven-parameter mutation tool, one sentence without structured detail is under-sized and does not give the agent enough material to act on.

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

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

With no annotations, no output schema, and a nested variable object, the description needs to explain scoping, required ids, and payload construction. It only says 'update by id', leaving critical invocation context missing.

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

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

Schema description coverage is 0%, and none of the seven parameters are explained. 'by id' only weakly hints at variable_id, while required account_id, container_id, workspace_id, and the nested free-form 'variable' object remain completely unspecified.

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

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

States a specific verb ('Update'), a specific resource ('GTM variable'), and the selection criterion ('by id'). The word 'existing' also distinguishes it from creating a 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?

No guidance on when to use this tool versus gtm_create_variable or gtm_list_variables. No prerequisites, exclusions, or alternatives are mentioned; only the basic action is implied.

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