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

No annotations provided and the description does not disclose behavioral traits such as idempotency, authorization needs, or rate limits. The description is minimal.

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?

Extremely concise: one sentence that directly states the tool's purpose with no unnecessary words.

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

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

For a simple read operation with one parameter, the description is adequate but lacks details about return format or any behavioral context. No output schema to supplement.

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

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

The input schema already describes the 'accountId' parameter with sufficient detail. The description adds no extra meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description 'Get details of a specific GTM account' clearly states the verb 'Get' and the resource 'details of a specific GTM account'. It differentiates from sibling 'accounts_list' by focusing on a single account retrieval.

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 on when to use this tool versus alternatives like 'accounts_list'. The context is straightforward but lacks exclusions or usage hints.

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 mentions the returned fields but does not disclose pagination behavior (truncated, nextPageToken) which is only described in the parameter schema. No side effects, permissions, or rate limits are mentioned.

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. However, it could be improved by briefly mentioning pagination or filtering capabilities.

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 mentions the returned fields but does not explicitly confirm that the result is a list or describe the structure. Pagination details are only in the schema. For a list tool with no output schema, additional context would be beneficial.

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

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

Schema description coverage is 100% (all parameters have descriptions). The description does not add value beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action (List), the resource (GTM accounts), and the scope (accessible to the authenticated user). It also lists the returned fields, distinguishing it from the sibling tool 'accounts_get' which retrieves a single account.

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 lacks any guidance on when to use this tool versus alternatives like 'accounts_get' or other listing tools. No prerequisites, conditions, or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states it's a read-only operation and never modifies anything, which is good. However, it omits details like authentication needs or rate limits.

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

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

Two sentences that efficiently convey the tool's purpose and key behavior. No superfluous information, and the read-only note is placed prominently.

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 4 parameters, no output schema, and no annotations. The description gives a high-level purpose but lacks details about the output structure, what specific issues are checked, or how the results are formatted. Agents may not know what to expect from the response.

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

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

Schema description coverage is only 25% (only includeInfo has a description). The description does not explain accountId, containerId, or workspaceId, forcing agents to infer from names. With low coverage, the description should compensate but fails to do so.

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

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

The description clearly states it inspects a GTM workspace for analytics implementation issues and returns structured findings with severity levels. It distinguishes itself from sibling tools like workspace_get_status and other read-only tools by focusing on auditing common issues.

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 describes when to use (to inspect for analytics issues) and declares it's read-only, but does not explicitly mention when not to use or suggest alternatives among the many sibling tools.

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

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

No annotations are provided, so the description carries full burden. It discloses the DELETE operation, required feature flag, and confirm parameter. However, it lacks details on side effects, reversibility, or rate limits.

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

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

The description is a single, front-loaded sentence with a crucial prerequisite note. No wasted words.

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

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

For a tool with no output schema, the description covers the core action and preconditions. It could be more complete by describing the effect of disabling variables, but it is sufficient for an agent to use 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 coverage is only 20% (only 'types' has a description). The description adds minimal parameter insight beyond confirming the 'confirm' flag. Other parameters (accountId, containerId, workspaceId) are left 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 clearly states the action ('Disable'), the resource ('built-in variables in a GTM workspace'), and includes a precondition note. It distinguishes from siblings like built_in_variables_enable and built_in_variables_revert.

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 for when to use the tool (to disable built-in variables) and mentions prerequisites (GTM_MCP_ENABLE_DELETES and confirm). However, it does not explicitly state when not to use it or compare with 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?

No annotations are provided, so the description carries full burden. It indicates a write operation and required confirm parameter, but lacks details on idempotency, limits, or consequences of re-enabling already enabled variables.

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 (two sentences) and front-loaded with the action, but could be better structured to include return value or error behavior without being verbose.

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 and 5 parameters, the description does not explain what the tool returns, error conditions, or further context about GTM workspace identification, leaving the agent underinformed.

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 low (20%), with only 'types' having a description. The description adds minimal meaning beyond the schema, not explaining the confirm boolean or the ID 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 'Enable' and the target 'one or more built-in variables in a GTM workspace', which is specific and differentiates from siblings like built_in_variables_disable and built_in_variables_revert.

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 mentions prerequisites ('GTM_MCP_ENABLE_WRITES=true and confirm=true'), giving clear context for when it's appropriate to use, but does not explicitly state when not to use or list 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 must disclose behavioral traits. It states it's a list (read) operation but does not mention auth requirements, rate limits, pagination beyond schema, or side effects. The description adds minimal transparency beyond the obvious.

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

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

A single, well-structured sentence that concisely communicates the tool's purpose without extraneous 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?

For a simple listing tool, the description covers the basic purpose but lacks details on return format and pagination behavior. Without an output schema, the description should at least hint at the structure of results. It is minimally complete but not thorough.

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 40% (only maxPages and pageToken have descriptions). The tool description does not explain any parameters or add meaning beyond the schema. For a tool with three required parameters (accountId, containerId, workspaceId), the description offers no guidance on their purpose or values.

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

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

The description clearly states the action (list), the resource (built-in variables), and the context (enabled, in a GTM workspace), distinguishing it from sibling tools like variables_list or built_in_variables_enable.

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 listing enabled built-in variables but does not explicitly guide when to use this tool versus alternatives like variables_list or built_in_variables_enable. No when-not-to-use or prerequisite information.

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

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

No annotations are provided, so the description carries full burden. It identifies the tool as a write operation and lists prerequisites, but does not detail the revert behavior (e.g., overwriting, reversibility, or side effects). This is adequate but could be more comprehensive.

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, no redundancy. Action is front-loaded, prerequisites follow. 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 5 required params, a destructive write, and no output schema, the description covers purpose and prerequisites but lacks parameter details and fuller behavioral context. It is minimally complete but has 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 only 20% (only 'type' described). The description mentions 'confirm' but not the other four parameters. It adds some meaning for confirm (requires true) but insufficiently compensates for the low schema coverage.

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

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

The description clearly states it reverts changes to a built-in variable, specifying the action and resource. It distinguishes from siblings like list, enable, disable through the revert action and write indicator.

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 mentions prerequisites (GTM_MCP_ENABLE_WRITES=true, confirm=true) and implies when to use (when reverting built-in variable changes). However, it does not explicitly state when not to use or mention alternatives among sibling tools.

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

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

No annotations provided, so the description carries full burden. It discloses the write operation, the need for confirmation, and the expected input format. However, it does not describe what happens on success/failure or return value, which is acceptable 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 a single sentence plus the [WRITE] label, with no wasted words. 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?

No output schema, so return value is not documented, but the tool is simple: it creates a client. The required parameters are clear from schema and context. The description covers the key behavioral aspects, making it mostly complete for agent 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?

Schema description coverage is 100%, so baseline is 3. The description adds a brief note about passing the resource as a JSON string in bodyJson, which reinforces the schema, but does not add significant new meaning beyond what the schema already provides through property 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?

Clearly states 'Create a new GTM client' with a verb and specific resource. The [WRITE] prefix and the list of sibling tools like clients_list and clients_get distinguish this creation action from read or update actions.

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?

Explicitly states requirements: GTM_MCP_ENABLE_WRITES=true and confirm=true. This guides the agent on when to use the tool and what conditions to meet. Does not explicitly mention alternatives, but the context of siblings implies when not to use it.

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

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

No annotations are provided, so the description must carry the full burden. It states 'Delete a GTM client' and requires confirmation, but does not disclose irreversibility, side effects on related entities, or required permissions. For a destructive operation, 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 directly states the operation and key requirements. It is front-loaded with the action and immediately useful for the agent, with no wasted words.

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

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

Given the lack of annotations, output schema, and 5 required parameters, the description covers the core action and prerequisites but omits details on response behavior, error cases, or permanence. It is minimally viable but leaves gaps for 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 coverage is 100%, setting a baseline of 3. The description adds value only for 'confirm' (must be true), but other parameters (accountId, containerId, etc.) have self-explanatory names and no additional context from the description.

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

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

The description explicitly states 'Delete a GTM client,' which is a clear verb+resource pair. The HTTP method and requirement are noted, distinguishing it from sibling tools like clients_list or clients_get by the delete 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?

The description mentions prerequisites (GTM_MCP_ENABLE_DELETES=true and confirm=true) but provides no guidance on when to use this tool versus alternatives like clients_revert or clients_get. It lacks explicit when/ when-not context.

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

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

With no annotations, the description bears full responsibility. It correctly indicates a read operation ('Get') but offers no additional behavioral details such as rate limits, authentication requirements, or error handling. The simplicity keeps it from being misleading but leaves 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 a single concise sentence, containing no wasted words. It is efficiently front-loaded and easy to parse.

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

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

For a getter tool with 4 required parameters and no output schema, the description is incomplete. It does not mention what the tool returns (the client resource) or common error conditions (e.g., not found). Given the complexity of the GTM API, more context is warranted.

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

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

Schema coverage is 100% (all 4 parameters have descriptions), so the description does not need to compensate. However, it adds no extra context beyond the schema, such as how parameters relate (e.g., clientId is unique within workspace). The baseline 3 is appropriate.

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

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

The description 'Get a specific GTM client' clearly states the action (get) and resource (GTM client). It is distinguishable from siblings like 'clients_list' by implying a single entity, though it does not explicitly mention the identifier parameter.

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 vs alternatives like clients_list or clients_create. There are no prerequisites or context given for invoking this tool correctly.

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 adds one behavioral detail: automatic pagination. However, with no annotations, it does not disclose read-only nature, permission requirements, or other side effects. This is minimal transparency beyond the schema.

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

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

Two short sentences with no redundancy. Purpose is stated first, followed by a key behavioral trait. 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 list tool, the description is adequate but minimal. It explains what the tool does and pagination, but lacks information about the response format or what fields are returned. Given no output schema, a hint about the return structure would improve completeness.

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

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

Schema coverage is 100%, so the baseline is 3. The description mentions pagination behavior, which relates to maxPages and pageToken, but does not add significant meaning beyond the schema descriptions.

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

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

Description clearly states the tool lists GTM clients in a workspace. The verb 'list' and resource 'GTM clients' are specific, and the scope 'in a workspace' is narrow. It implicitly distinguishes from single-resource tools like clients_get, but doesn't explicitly differentiate from other list tools.

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

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

No guidance on when to use this tool versus alternatives (e.g., clients_get for a single client, or other listing tools). No prerequisites or context for usage are provided.

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

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

No annotations provided, so description carries full burden. It adds write context and prerequisites, but does not disclose destructive nature, scope of reverted changes, or handling of fingerprint parameter. Lacks details about what exactly gets reverted.

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: first describes action and resource, second states prerequisites. No fluff, front-loaded with essential 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?

Provides high-level purpose and prerequisites. Lacks details about return value (no output schema) and potential failure conditions. However, given the simple parameter set and no nested objects, it is mostly 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 coverage is 100% with descriptions for all 6 parameters. The description adds no additional parameter-level info beyond the schema, hence baseline 3.

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 specific verb 'revert' and resource 'GTM client', and clearly distinguishes from other revert tools for different entities (e.g., built_in_variables_revert, templates_revert). The '[WRITE]' prefix further clarifies the operation type.

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?

Explicitly states prerequisites: GTM_MCP_ENABLE_WRITES=true and confirm=true. It implies the tool is for undoing client workspace changes, but does not compare with alternatives like clients_update or other revert tools for different entities.

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?

Without annotations, the description carries full burden. It discloses the write nature, required enable flag, and confirm parameter, but omits details like optimistic locking (fingerprint), error behavior, or response format. Adequate but not comprehensive.

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?

Extremely concise: one sentence plus a pragmatic note. The '[WRITE]' tag front-loads the operation type. 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?

For a 7-parameter tool with no output schema, the description is too sparse. It does not explain critical aspects like the full resource requirement, fingerprint usage for concurrency, or what the response contains. Incomplete for agent decision-making.

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

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

Schema coverage is 100%, so baseline is 3. The description repeats schema info about bodyJson and does not add new semantics beyond what properties already convey.

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

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

The description clearly states the verb 'Update' and resource 'existing GTM client', with a '[WRITE]' prefix that distinguishes it from read-only tools. It is specific 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?

The description implies usage for updating an existing client but does not explicitly contrast with related siblings like clients_create or clients_delete. It provides important prerequisites but lacks 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 provided, the description attempts to disclose behavioral traits by marking it as [WRITE] and warning with a hazard symbol, but it does not explain the full impact (e.g., whether the source container is deleted or remains) or required permissions beyond the environment variable.

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 consists of two clear, front-loaded sentences that convey the action, requirements, and a warning without unnecessary 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?

Given the complexity of a merge operation and no output schema, the description lacks details on post-merge behavior (e.g., what happens to the source container, how conflicting settings are resolved) and does not fully compensate for missing annotations.

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

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

Schema coverage is 100%, so the description adds little value beyond what the schema already provides. It mentions key parameters like containerIdToCombine and confirm but does not elaborate on settingSource or allowUserPermissionFeatureUpdate.

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 ('combine/merge'), the resource ('another container into this one'), and specifies the source and target by ID, distinguishing it from sibling tools like containers_create or containers_move_tag_id.

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 indicates prerequisites (requires GTM_MCP_ENABLE_WRITES=true and confirm=true) and provides a clear context for when to use the tool, but does not explicitly state when not to use it or suggest 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?

No annotations provided, so description carries full burden. Discloses that this is a write operation (mutation) and requires explicit confirmation. Omits details like return value or error handling, but core behavioral traits are stated.

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

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

One sentence with two clear parts: action and requirement. No redundancy, front-loaded, 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 6 parameters (4 required) and no output schema, the description captures the essential: creation action and critical prerequisite. Schema fully describes parameters, so extra detail is unnecessary. Missing info about post-creation confirmation or return, but adequate for a create tool.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds no additional meaning beyond the schema; it only mentions the confirmation requirement, which is already in the schema description. No extra semantic depth.

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?

Clearly states '[WRITE] Create a new GTM container'. Verb 'create' and resource 'GTM container' are specific. Distinguishes from sibling tools like containers_get, containers_list, and other create tools (tags_create, etc.) by resource type.

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?

Explicitly states necessary preconditions: 'Requires GTM_MCP_ENABLE_WRITES=true and confirm=true'. This tells the agent when to use this tool (only with writes enabled) and that confirmation parameter must be true, guiding correct invocation.

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 must carry the burden. It states a read operation ('Get details') but does not disclose permissions, side effects, or any constraints. Minimal transparency.

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 is front-loaded and concise.

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

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

For a simple get operation, the description suffices to indicate a read. However, without an output schema, the agent does not know what details are returned, leaving some incompleteness.

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

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

Schema coverage is 100% with clear parameter descriptions for accountId and containerId. The description adds little beyond implying the need for both IDs. Baseline score is appropriate.

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

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

The description uses a specific verb 'Get' and resource 'details of a specific GTM container', making the purpose clear. However, it does not differentiate from sibling tools like accounts_get or clients_get, which follow the same pattern.

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 containers_list or containers_lookup. The description lacks context for decision-making.

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 proactively discloses automatic pagination handling ('Automatically follows pagination to return all containers'), which is a key behavioral trait beyond the input schema. With no annotations, this adds significant transparency about expected behavior and limits.

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

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

Two short sentences, each essential. The first states the core purpose, the second adds a critical behavioral detail. 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 list tool with 3 parameters and no output schema, the description covers the main function and pagination behavior. It could mention the output structure or field set, but overall it is sufficiently complete given the 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 100%, so the schema already explains each parameter (accountId, maxPages, pageToken). The description adds no additional meaning beyond what is in the schema, meeting the baseline expectation.

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 'List all GTM containers within a GTM account' with a specific verb ('list'), resource ('containers'), and scope ('within a GTM account'). It distinguishes from sibling tools like containers_get or containers_create by focusing on listing all containers.

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 listing all containers in an account but lacks explicit guidance on when not to use it or comparison with alternatives like containers_lookup or containers_get. No exclusions or context-switching cues are provided.

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

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

No annotations provided; description lacks details on read-only behavior, error handling (e.g., if destination ID not found), or permissions. Minimal behavioral disclosure.

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?

Single sentence, front-loaded with key information, no unnecessary 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?

Simple tool with one parameter and no output schema; description adequately explains lookup purpose but does not mention what the function returns or if multiple containers can share a destination ID.

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

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

Schema coverage is 100% with property description. Description adds contextual context like 'linked' and examples, but baseline 3 applies as schema already documents 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?

Description clearly states the verb 'Look up', the resource 'GTM container', and the unique parameter 'linked destination ID' with examples. Distinguishes from sibling tools like containers_get which use container ID.

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?

Implies usage when you have a destination ID rather than a container ID, but does not explicitly state when to use versus alternatives like containers_get, containers_list, etc.

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 provided, so the description carries full burden. It notes '[WRITE]' and required confirm flag, but does not explain the move process (e.g., deletion, copy behavior), side effects, or authorization details beyond the generic prerequisite.

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 purpose, minimal waste. Could include destination info but remains 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?

For a 9-parameter tool with no output schema, the description is too brief. It omits explanation of 'move' semantics, destination container (missing from schema), and the role of copy* parameters. Incomplete 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?

Schema description coverage is 89%, so the schema already documents most parameters. The description only reinforces the 'confirm' requirement, adding no new semantic value. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Move') and resource ('Tag ID'), and distinguishes from sibling tools (e.g., tags_create, containers_combine). However, it lacks clarity on the destination container, which is not in the schema, potentially causing confusion.

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 like tags_create or containers_combine. Prerequisites are mentioned (ENABLE_WRITES, confirm) but no usage context or exclusions.

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

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

With no annotations, the description fully discloses the write nature, the read-modify-write pattern to preserve other fields, the rejection of non-server containers, the URL recording being config-only (no deployment), and the required flags. This is comprehensive 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 two sentences, with the first sentence front-loading the key action and context. Every word adds value: the prefix '[WRITE]', the purpose, the pattern, the constraints, and prerequisites. No redundant or irrelevant 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 the tool is a simple write operation with no output schema, the description covers the essential behavioral aspects, prerequisites, and constraints. It does not specify the return value or error messages, but for a parameterized setter, this is adequate. The missing details are minor.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining serverUrls are 'deployed tagging-server URL' examples (Cloud Run/Stape), and confirms the confirm parameter's role. It also clarifies the containerId must be for a server container, which is not enforced by 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 specific action: setting taggingServerUrls on a SERVER container. It specifies the resource (SERVER container), the verb (set), and provides context (read-modify-write via containers.update). It also distinguishes from generic updates by noting it rejects non-server containers and only records the URL without deploying.

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 the tool is for SERVER containers only and rejects others. It also states the prerequisites (GTM_MCP_ENABLE_WRITES=true, confirm=true). However, it does not mention alternative tools like containers_update for directly modifying the resource, leaving the agent to infer when to use this specialized setter.

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 behavioral traits. The description only states the action without mentioning any side effects, authorization requirements, rate limits, or output format. Minimal transparency.

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?

Single sentence, no wasted words. Front-loaded with the essential information. 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?

Given no output schema and no annotations, the description is minimal. It provides the basic purpose but lacks details about return format, prerequisites, or behavior. For a simple retrieval tool it is adequate but not complete.

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

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

Schema description coverage is 100% for both parameters, so the baseline is 3. The description adds no additional meaning beyond what the schema already provides, but it does not detract either.

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 'Get' and the specific resource 'GTM installation snippet (HTML/JS tagging code)'. It distinguishes from sibling tools like 'containers_get' which retrieve container metadata, not the snippet.

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 on when to use or when not to use this tool versus alternatives. However, the action is straightforward and the name clearly indicates its purpose, so usage is implied. Lacks exclusionary context.

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

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

With no annotations, the description fully carries behavioral disclosure. It declares 'WRITE', explains side effects (enables built-in variables, reuses/creates trigger, creates tag in draft workspace), and reveals important behaviors like refusing placeholder Measurement IDs and resolving them from the container unless allowPlaceholderId is set. It also notes that trigger reuse happens by 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 dense but every sentence earns its place—each clause adds critical usage or behavioral context. It front-loads the purpose with [WRITE] and PREFERRED, then efficiently explains the single-call benefit, alternatives, and safety guardrails without 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 complex 11-parameter tool with nested objects, no annotations, and no output schema, the description is remarkably complete. It covers prerequisites, side effects, parameter semantics, safety caveats (placeholder refusal), and explicitly contrasts with the multi-step alternative. The inclusion of GTM-specific field shapes and resolution behavior makes it self-sufficient.

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

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

Despite the schema having 100% coverage with detailed descriptions, the description adds significant semantic value. It explains eventParameters are plain name/value pairs and not the GTM list-of-maps shape, that variable references like {{Click URL}} are enabled automatically, and clarifies the nuanced allowPlaceholderId behavior and Measurement ID validation.

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+resource: '[WRITE] PREFERRED way to create a GA4 event tag that fires on an event.' It clearly states the tool builds a correct GTM resource from plain fields and links it to a trigger in the draft workspace. It also distinguishes itself from siblings like tags_create, triggers_create, and built_in_variables_enable.

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 this instead of tags_create + triggers_create + built_in_variables_enable, which need three round trips and get shapes wrong. It also states prerequisites (GTM_MCP_ENABLE_WRITES=true and confirm=true) and gives trigger kind guidance such as using link_click for <a> clicks and all_clicks for any element.

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 disclosing behavior. It labels the operation as [WRITE], states the requirement for GTM_MCP_ENABLE_WRITES=true and confirm=true, and warns about the data_layer blank-value pitfall. It does not describe error behavior or irreversibility, but it covers the key behavioral requirements.

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

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

The description is a single dense paragraph that front-loads the core concept and then expands each kind. While lengthy, every sentence contributes useful information and the format mirrors the kind selection decision tree. A bulleted list would improve scannability, but the current structure is acceptable.

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 complexity (12 params, 6 required, no output schema) and no annotations, the description does a strong job of covering the essential usage context: kind definitions, prerequisites, and the special case that event_data and request_header are server-only. It does not explain return values, but that is a minor gap for a create 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?

Schema coverage is 100%, so the baseline is 3. The description adds substantial cross-parameter meaning by mapping each kind to its applicable parameters (e.g., dataLayerName for data_layer, javascript for javascript) and explaining the semantic difference, such as dot-notation for nested keys and the requirement that javascript be a full function.

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 'Create a GTM variable by KIND rather than by GTM's internal type code, so the right shape is guaranteed,' which clearly identifies the tool's specific value proposition and distinguishes it from generic variable creation. It enumerates the supported kinds, 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 clear when-to-use guidance for each kind, such as 'only correct when the site actually pushes that key' for data_layer and 'the right choice for deriving something from the page or the click' for javascript. It also includes an explicit when-not: 'a data_layer variable CANNOT do this and would report blank.' However, it does not explicitly contrast this tool with sibling tools like variables_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?

No annotations are provided, so the description must carry behavioral context. It only says 'get details' with no mention of read-only nature, side effects, or required permissions. The schema implies required IDs but the description adds no behavioral traits.

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

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

The description is a single sentence with no extraneous words. It is front-loaded and efficient, though it could include a bit more context without losing conciseness.

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

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

Given the schema fully documents the parameters and there is no output schema, the description is minimally adequate. However, it lacks information about return data, authentication, or error conditions, which would be helpful for a 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 100% with clear descriptions for all three required parameters. The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'details of a specific GTM destination', making the purpose unambiguous. It distinguishes from sibling tools that operate on different resources (e.g., accounts, containers) but does not explicitly differentiate from destinations_list.

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 destinations_list or other 'get' tools. The description lacks context on prerequisites or typical use cases.

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 provided; description only flags write operation and required flags but omits behavioral details like idempotency, error cases, or effects of relinking.

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

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

Two sentences with a clear [WRITE] tag front-loaded; no unnecessary 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?

Covers requirements but lacks details on success behavior, error handling, or how to obtain destinationId; adequate for a simple mutation but could be richer.

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

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

Schema covers 4 of 5 params; description adds example for destinationId and reinforces confirm flag, but leaves allowUserPermissionFeatureUpdate 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?

Description specifies verb 'Link' and resource 'destination to GTM container', clarifying it's a write operation distinct from read siblings like destinations_get and destinations_list.

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?

Explicitly states prerequisites (GTM_MCP_ENABLE_WRITES=true and confirm=true), though it doesn't mention when not to use or alternatives for reading links.

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 provided, so description carries full burden. It only states 'list all destinations' without disclosing whether it's read-only, permissions needed, pagination, or side effects. For a listing 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, clear sentence with no wasted words. It is front-loaded with the action and 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?

Given the tool's simplicity (2 required params, no nested objects, no output schema), the description is minimally adequate but lacks details on return format, pagination, or any behavioral notes that would help an agent 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?

Schema has 100% coverage with clear descriptions for accountId and containerId. The description adds no additional meaning beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and resource 'destinations', specifies context 'for a GTM container', and distinguishes from siblings like destinations_get and destinations_link.

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 listing all destinations, but provides no explicit guidance on when to use this tool versus alternatives like destinations_get or destinations_link, nor any prerequisites.

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 provided, so description carries burden. It discloses it's a write operation requiring confirmation but lacks details on side effects, response format, or permissions beyond the prerequisites.

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

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

Extremely concise: one line with action and requirement. The [WRITE] prefix front-loads important context. No wasted words.

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

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

For a create tool with 7 parameters and no output schema, the description could include what the response contains or link to retrieval tools like environments_get. Current description is minimal but not 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 coverage is 100%, so baseline is 3. Description adds no additional parameter information beyond what the schema already provides.

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

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

Description clearly states verb 'Create' and resource 'GTM environment'. The [WRITE] prefix and name clearly distinguish from read tools like environments_get or update tools like environments_update.

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?

Explicitly states prerequisites (GTM_MCP_ENABLE_WRITES=true and confirm=true), guiding the agent on when to invoke. No mention of alternatives, but the resource-specific name makes usage clear.

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

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

No annotations are provided, so the description must carry the full burden. It discloses that the operation is destructive and requires a feature flag and confirm parameter, but lacks details on reversibility, permissions, 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 very short (one sentence plus bracket prefix) with no wasted words. While efficient, it could benefit from a slightly more structured format (e.g., listing requirements separately).

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 delete tool with 4 well-documented parameters and no output schema, the description covers the essential prerequisites but lacks details on success/error behavior or permissions, which would be helpful given the absence of annotations.

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

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

Schema coverage is 100%, so the schema already documents all parameters. The description adds no additional meaning beyond what the schema provides, resulting in baseline score.

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

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

The description clearly states 'Delete a GTM environment' with the HTTP method [DELETE], providing a specific verb and resource. Among sibling environments_* tools, only this one performs deletion, so it is well-distinguished.

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 mentions prerequisites (GTM_MCP_ENABLE_DELETES=true and confirm=true) but does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or context for when not to use it.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Get details,' implying a read operation, but lacks explicit statements about side effects, rate limits, or required permissions. The simplicity of the operation partially mitigates this, but the description misses an opportunity to be transparent about its non-destructive nature.

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

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

The description is a single sentence of 8 words, efficiently conveying the tool's purpose without redundancy. It is front-loaded with the action and resource, 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?

Given the simplicity of a get operation with three required parameters and no output schema, the description provides minimal context. It does not explain what 'details' includes or any error conditions. While sufficient for a straightforward GET, it lacks completeness for an agent to fully understand the response structure.

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

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

Schema coverage is 100%, with each parameter having a brief description (e.g., 'The GTM account ID.'). The tool's description does not add any additional meaning or context for the parameters, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Get') and the resource ('details of a specific GTM environment'). It effectively distinguishes this tool from sibling tools like environments_list (list all) and environments_create (create new), making its purpose 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 usage context is provided. The description does not specify when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. It simply states what the tool does without any guidance on appropriate 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals automatic pagination, which is a key behavior, but does not address safety, idempotency, rate limits, or error handling. The description adds value beyond the schema but is minimal.

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 that front-load the primary action and a key feature. No redundant or extraneous 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 the tool's simplicity, the description covers the core functionality (listing with pagination) and leverages the schema for parameter details. It could mention the output format or error conditions for completeness, but the current content is largely 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 100%, so the baseline is 3. The description adds no extra meaning beyond the schema: it does not explain parameter usage or relationships beyond what is already in the schema definitions.

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 that the tool lists all environments in a GTM container and automatically handles pagination, which is a specific verb+resource combination. While it distinguishes from sibling list tools by specifying 'environments', it does not explicitly contrast with other environment-related tools like environments_get or environments_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 lacks guidance on when to use this tool versus alternatives such as environments_get (for a single environment) or environments_create. No exclusions or prerequisites are mentioned, leaving the agent to infer usage context.

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

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

Without annotations, the description carries full burden. It discloses the destructive behavior: 'This rotates the environment auth token; any embedded snippet using the old token stops working until updated.' This is good, but could also mention if the operation is irreversible or any rate limits.

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

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

The description is concise with two sentences and a warning. Every sentence is essential, and the key points are 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 description covers prerequisites and side effects but lacks information about the return value or output. Since there is no output schema, the agent may not know what to expect after successful reauthorization. Otherwise, it's adequate for a high-impact mutation.

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

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

The input schema has 100% description coverage for all 4 parameters. The description adds that 'confirm' must be true, but this is already in the schema as required with a description. No additional meaning is added 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 'Re-generate the authorization code for a GTM environment' which specifies the verb (re-generate) and resource (authorization code). This distinguishes it from sibling tools like environments_list, get, create, update, delete.

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 prerequisites: 'Requires GTM_MCP_ENABLE_PUBLISH=true and confirm=true.' It also warns about the impact of rotating the token. However, it does not explicitly state when not to use this tool or suggest 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 full burden for behavioral disclosure. It indicates a write operation and mentions requirements, but lacks details about side effects (e.g., environment state changes, propagation to preview), optimistic locking via fingerprint, or error conditions. The [WRITE] label is helpful but 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?

Two sentences with a clear [WRITE] label and essential requirements. No unnecessary words; every part earns its place. Ideal conciseness.

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

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

Given the complexity (9 parameters, no output schema, no annotations), the description is too minimal. It does not explain return behavior, error handling, optimistic locking, or what happens after a successful update. An agent lacks sufficient context to use this tool safely and 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?

Schema coverage is 100%, so the baseline is 3. The description adds context that 'confirm' must be true, reinforcing its role as a safety check. However, it does not add meaningful semantics beyond the schema for other parameters, such as the purpose of fingerprint or the optional fields.

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

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

The description clearly states the verb 'Update' and resource 'GTM environment', with a [WRITE] prefix indicating it's a mutation. This distinguishes it from read-only environment tools like environments_list and environments_get, but does not explicitly differentiate from environments_create or environments_reauthorize.

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 prerequisite conditions: requires GTM_MCP_ENABLE_WRITES=true and confirm=true. This gives guidance on when the tool can be invoked but does not explain when to use this tool vs. alternatives like environments_create for new environments or environments_reauthorize for token refresh.

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?

Without annotations, the description carries the burden and explicitly states 'This is a read-only operation', which is a key behavioral disclosure. It also describes what is returned, but does not mention pagination or potential truncation, though the schema's maxPages description covers some of that.

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

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

Three concise sentences: purpose, return contents, and use cases. No fluff, every sentence adds value, and key info 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 description gives a solid overview of purpose, output, and read-only nature, but lacks details about the JSON structure, truncation semantics, or pagination behavior. The schema partially covers maxPages, but without an output schema or annotations, the description could provide more complete 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 only 40%, and the description adds no parameter context. The required IDs (accountId, containerId, workspaceId) have no documentation in either schema or description. The format and maxPages parameters are explained in the schema, but the description doesn't compensate for the low coverage.

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

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

The description clearly states a specific verb ('Export'), resource ('full GTM workspace summary'), and output ('structured JSON'), listing all included components (tags, triggers, variables, folders, built-in variables). This distinguishes it from sibling list/get tools that target individual entities.

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 use cases ('documentation, auditing, or feeding container data to other tools') that imply when to use this tool. However, it does not explicitly compare to alternatives like containers_get or audit_container, nor state when not to use it.

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

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

With no annotations, the description correctly indicates this is a write/mutation operation via the [WRITE] prefix and specifies required environment variable and parameter conditions, but lacks details on side effects, idempotency, or error handling.

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

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

The description is one sentence with a clear prefix, achieving brevity, but it omits important details that could be added without significant length.

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

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

Given the tool has 6 parameters, no output schema, and no annotations, the description is insufficient for an agent to understand the full context, especially with many sibling creation tools that require differentiation.

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

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

Schema coverage is 0%, yet the description only clarifies the 'confirm' requirement for safety, leaving the meaning of 'name', 'notes', 'accountId', 'containerId', and 'workspaceId' unexplained. The description fails to compensate for the missing schema descriptions.

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

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

The description clearly states the action ('Create a GTM folder') with a write indicator, differentiating from read-only folder tools like folders_get and folders_list that also exist among siblings.

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

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

The description provides a prerequisite (GTM_MCP_ENABLE_WRITES=true and confirm=true) but offers no guidance on when to use this tool over other create tools (e.g., tags_create, triggers_create) or when not to use it.

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

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

With no annotations, the description carries full burden. It discloses the destructive nature (DELETE), prerequisites, and that folder contents are unfoldered, not deleted. This adds significant behavioral context beyond the name, but misses details like reversibility 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 two sentences, front-loaded with the action, and every sentence provides essential information (action, prerequisites, consequence on contents). 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?

Given a destructive tool with 5 required params and no output schema or annotations, the description lacks detail on return values, error handling, pre-deletion checks, or idempotency. It only covers basic behavior.

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

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

Schema description coverage is 0%, so the description should compensate. It only clarifies the 'confirm' parameter (must be true) but ignores other required params (accountId, containerId, workspaceId, folderId), leaving their purpose implicit.

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 'Delete a GTM folder', specifying the verb and resource. It distinguishes from read or update tools but does not explicitly compare to other folder deletion tools among siblings.

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

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

The description provides prerequisites (GTM_MCP_ENABLE_DELETES=true, confirm=true) and notes that contents are unfoldered, implying when to use. However, it lacks explicit guidance on when not to use or alternatives like folders_move_entities.

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 burden of behavioral disclosure. It adds useful information about automatic pagination ('Automatically follows pagination to return all entities'), but it does not disclose read-only nature, required permissions, or output format. The pagination detail is a positive, but overall disclosure is minimal.

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 concise sentences that front-load the primary action and entity types, then add the pagination behavior. Every word adds value, and there is no redundant or filler 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?

Given the tool has 4 required parameters, no annotations, no output schema, and only 33% schema coverage, the description is moderately complete. It covers the core action and pagination, but lacks parameter context, return value structure, and permission requirements. It is acceptable for a simple list operation but leaves room for ambiguity.

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

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

Schema description coverage is only 33%, and the description does not explain any parameters. It mentions 'specific GTM folder' which implies folderId, but accountId, containerId, and workspaceId are left undocumented. maxPages and pageToken have schema descriptions, but the tool description does not provide additional meaning or compensate for the low coverage.

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

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

The description clearly states the action (List), the resource (entities: tags, triggers, variables), and the scope (within a specific GTM folder). This distinguishes it from sibling tools like tags_list, triggers_list, and variables_list, which list individual entity types without folder filtering.

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 all entity types within a folder, but it does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites. The context is clear enough for a basic understanding, but lacks explicit guidance.

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

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

No annotations provided, and the description does not disclose any behavioral traits (e.g., read-only, idempotent, error conditions, permissions). The description carries the full burden but fails to convey even that this is a safe 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 overly terse (one sentence). Conciseness should not sacrifice necessary information; here, critical details are omitted, making it under-specified.

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 4 required parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain the concept of a GTM folder, the relationship between IDs, or the expected response.

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 any of the four required parameters (folderId, accountId, containerId, workspaceId). The agent receives no guidance on what each parameter represents or how to obtain 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 'Get a specific GTM folder' clearly states the verb (Get) and resource (GTM folder), distinguishing it from sibling tools like folders_list (list all) and folders_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?

No guidance on when to use this tool vs alternatives (e.g., folders_list for multiple folders, folders_create for new ones). No context on 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?

Discloses automatic pagination handling, which is a key behavioral trait. However, no information about performance, rate limits, or that it's a read-only operation. Without annotations, this is acceptable but not comprehensive.

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, each providing essential information. Front-loaded with purpose, no redundant or extra 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 complexity (5 params, no output schema, no annotations), the description is minimal. It lacks details on output format, error handling, expected behavior when no folders exist, or how the pagination token works.

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 40% (2 of 5 parameters described). The description does not add meaning to the undocumented parameters (accountId, containerId, workspaceId), which are required but not explained.

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 'List all GTM folders in a workspace' with a specific verb and resource. It distinguishes from sibling tools like folders_get (single folder) and folders_entities (entities within a folder).

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 on when to use this tool versus alternatives (e.g., folders_get for a single folder). Implied by 'all folders' but lacks when-not or prerequisite info.

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 disclose behavioral traits. It only mentions a prerequisite and confirm parameter, omitting details about side effects, reversibility, permissions, or behavior when confirm is false.

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 very short and front-loaded with the action, no wasted words. Slightly more structure could improve clarity.

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

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

Given 8 parameters, no output schema, and no annotations, the description is too brief. It lacks details on return values, confirmation mechanism, and broader usage context for Google Tag Manager.

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 minimal meaning beyond the schema ('Move tags/triggers/variables'), but schema coverage is 50%, so partial value is provided. It doesn't explain parameter relationships or usage.

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 ('Move tags/triggers/variables into a folder') and resource, distinguishing it from sibling read tools. However, it could be more specific by explicitly mentioning Google Tag Manager and the entity types.

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 usage conditions (writes enabled, confirm=true) but lacks strategic guidance on when to use this tool versus alternatives like folders_create or other move 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?

No annotations are provided, so the description bears full responsibility. It only states the write nature and requirement, omitting details on idempotency, error handling, or effects of incomplete 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?

A single sentence with no filler, front-loaded with [WRITE], efficient and direct.

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 complexity (8 parameters, no output schema, no annotations), the description lacks completeness. It fails to describe return values or parameter roles beyond confirm.

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 and 8 parameters, the description adds no value for most parameters. It only mentions confirm but not name, notes, fingerprint, or required IDs.

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 updates a GTM folder, distinguishing it from sibling tools like create, delete, or list by using 'Update' and the [WRITE] prefix.

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 requires GTM_MCP_ENABLE_WRITES=true and confirm=true, providing necessary usage constraints. However, it does not contrast with alternatives like folders_create, though the context implies modification of existing folders.

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?

Without annotations, the description carries the full burden. It correctly identifies the tool as read-only and provides a 'lightweight' hint about the response. However, it does not disclose potential rate limits, the exact structure of the account summary, or any other behavioral traits beyond what the schema already implies about pagination.

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 extremely concise, consisting of two sentences and a 'Read-only' label. It front-loads the main action and purpose, with no redundant information. Every sentence serves a clear 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?

Despite lacking an output schema, the description adequately explains the return value: account plus property summaries with IDs and display names. This is sufficient for an agent to understand the response. However, it could be slightly more explicit about the structure of the account part.

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

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

The input schema has 100% description coverage for its two parameters (maxPages, pageToken). The tool description does not add any additional meaning or context about these parameters, so it meets the baseline expectation without extra contribution.

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 GA4 account summaries accessible to the user, specifying the content (account + lightweight property summaries with ID and display name). It distinguishes itself as the best starting point for discovering accounts and properties, setting it apart from sibling tools like ga4_properties_list.

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 usage context by stating it is the 'best starting point to discover available GA4 accounts and properties.' It also marks the tool as read-only. However, it does not explicitly mention when not to use it or list alternative tools for more detailed property information.

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 this is a write operation ('[GA4 WRITE]') and that it is required once for certain operations. However, it does not describe the outcome, reversibility, or response format, leaving some behavioral aspects unclear.

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 with no wasted words. It is front-loaded with the purpose and efficiently provides usage context and requirements. Every sentence serves a 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?

Given the tool's simplicity and lack of output schema, the description covers purpose, usage context, and requirements. It could mention the expected response (e.g., success acknowledgment), but overall it is sufficiently complete for an agent 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?

The schema has 50% coverage (property described, confirm not). The description adds value by noting that 'confirm=true' is required, which goes beyond the schema. The property parameter is standard and the schema description suffices.

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 purpose: to acknowledge that the property owner has the required user privacy disclosures/rights. It uses a specific verb ('Acknowledge') and resource, and distinguishes from sibling tools by explaining it's a prerequisite for other operations like creating links or MP secrets.

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 mentions when to use it: 'Some operations (e.g. creating certain links or MP secrets) require this once.' It also lists prerequisites: 'Requires GA4_MCP_ENABLE_WRITES=true and confirm=true.' However, it doesn't specify when not to use it or provide 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?

No annotations are provided, so the description carries the burden. It discloses that archiving is effectively permanent and irreversible. However, it does not describe side effects on related data or whether the audience is entirely removed from reports. The mention of 'stops collection' is helpful but lacks depth 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?

Two sentences deliver all essential information: purpose, permanence, prerequisites. No extraneous text. The [GA4 DELETE] prefix clearly signals it is a destructive operation. Excellent conciseness.

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

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

For a tool with two required parameters and no output schema, the description covers purpose, permanence, and configuration needs. It does not explain the response or further effects, but the simplicity of the operation makes this acceptable. Slightly better completeness would address what happens to the audience data after archiving.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The tool description reinforces that confirm must be true and that name is a resource name, but adds no new detail beyond schema. Baseline 3 for high coverage.

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

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

The description clearly states the tool archives an audience, stopping collection, and emphasizes permanence. The verb 'archive' distinguishes it from delete tools like ga4_delete_property, and the parenthetical 'no un-archive' sets clear expectations.

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 requires GA4_MCP_ENABLE_DELETES=true and confirm=true, giving clear prerequisites. It does not list alternative tools for un-archiving, but the permanent nature inherently advises caution. Could be improved by stating when not to use (e.g., if re-activation might be needed).

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 discloses key behaviors: permanent effect, no un-archive, and prerequisite configuration. Lacks detail on potential data impact.

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?

Extremely concise—two sentences with no filler, front-loaded with danger signal. 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?

Complete for a simple, 2-param tool with no output schema: covers purpose, usage, behavior, and prerequisites.

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