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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the specific domains it validates, which is useful context beyond the annotations. However, it does not disclose behavior like what happens if the recordId is invalid, whether it aggregates data from other services, or how findings are reported. This is acceptable given the annotations already assure safety.

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

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

The description is a single, efficient sentence that front-loads the action ('Check') and lists the specific areas. It contains no filler and gets to the point immediately. The structure is clear 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 simple read-only check with one parameter, the description covers the main scope of the tool. However, it does not describe the return value or output format, nor does it mention any preconditions (e.g., requiring an existing record). Since there is no output schema, the description could reasonably state that it returns a readiness assessment, but its absence leaves some ambiguity for agents expecting a structured result.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'recordId' parameter. The description does not mention recordId at all, leaving agents to infer its meaning from the tool name and context. While it is a common identifier, the tool does not clarify its format, scope (e.g., GTM record vs. another entity), or required context. This is a notable gap.

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

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

The description states a clear verb ('Check') with a specific resource and enumerates the aspects being checked: lifecycle, verification, ownership, runbook linkage, and pending source updates. This is specific enough to convey the tool's core function, though it does not explicitly differentiate it from siblings that also relate to status or readiness, such as gtm_module_status or gtm_get_record.

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

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

The description provides no guidance on when to use this tool versus the alternative sibling tools. It does not state conditions, prerequisites, or exclusions. Given the large sibling set, an agent receives no help in choosing this over gtm_module_status or gtm_get_record for a similar readiness inquiry.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the 'active' qualifier and runbook categories, which is useful semantic context, but it does not reveal behavior such as search semantics, ordering, pagination, or what happens when no query is supplied.

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

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

The description is a single short sentence with no filler, and the core action and scope are front-loaded. It earns a high score for economy, though the economy comes at the cost of necessary detail.

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

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

For a simple read-only finder, the annotations carry the safety context, but with no output schema and no parameter descriptions the tool is only minimally actionable. Information about what fields are searchable, what the result set looks like, and when to prefer this over related catalog tools is missing.

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

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

Schema description coverage is 0%: the input schema defines 'limit' and 'query' with no descriptions, and the tool description does not explain either parameter. An agent cannot tell what 'query' searches against or how 'limit' affects results, so the parameter semantics are effectively undocumented.

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

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

The description uses a specific verb ('Find') with a clear resource ('runbooks') and adds scope qualifiers ('active operating, incident, escalation, and recovery'). This clearly identifies the tool's domain, though it does not explicitly contrast it with sibling tools like gtm_search_catalog.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of when gtm_search_catalog or other siblings would be more appropriate. The intended context must be inferred entirely from the tool name and terse description.

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

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

Annotations already indicate a safe, read-only, idempotent operation. The description adds useful behavior context beyond that: the generated output is only a draft and must be verified against current platform data. This is a meaningful, non-redundant behavioral caveat.

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

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

The description is a single compact sentence with two meaningful clauses and no filler. It front-loads the main purpose and then adds the key limitation, earning its place 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?

The tool is simple with one parameter and rich annotations, but the absence of any templateKey guidance is a significant gap, especially with no output schema and 0% schema description coverage. The draft/verification warning is helpful, but the definition is not fully complete for an agent that must construct a valid invocation.

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

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

The schema has one required parameter, templateKey, with 0% schema description coverage, so the description must explain it. The text never mentions templateKey, how to obtain a valid value, or what templates are eligible, leaving the agent without enough information to invoke the tool correctly.

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

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

States a clear verb and resource ('Generate safe CSV headers/examples') and adds that the output is a draft requiring verification. It does not explicitly differentiate from sibling tools like gtm_list_bulk_templates or gtm_validate_bulk_change, so it falls just short of a 5.

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

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

The phrase 'draft templates require verification against a current platform export' gives some context about how the output should be used, implying a follow-up validation step. However, it does not explicitly state when to choose this tool over alternatives or mention the likely sibling gtm_validate_bulk_change.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the 'Find' verb is consistent with a non-mutating read. The description adds the breadth of retrieval (multiple entity types in one call) but discloses no further behavioral traits such as query semantics, aggregation behavior, or result structure. With strong annotation coverage, a 3 is appropriate.

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

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

A single front-loaded sentence with an immediate verb and a compact list of retrieved entities — no filler or repetition. It is efficient, though the brevity comes at the cost of the missing usage and parameter guidance noted above.

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 broad multi-entity retrieval tool with an ambiguous required query parameter, no output schema, and 14 overlapping siblings, the description is too thin. It should clarify what a query returns, how limit applies, and how results relate to the sibling tools, none of which is addressed.

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 compensate: it never explains what the required 'query' parameter does (keyword search across entities? account name match?) or what 'limit' bounds. The schema provides only types, min/max, and a default, leaving both parameters semantically ambiguous for an agent.

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

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

The description states a specific verb ('Find') and resource (platform account context) and enumerates the entity types retrieved: IDs, contacts, APIs, owners, agencies/vendors, integrations, runbooks, systems. However, several listed outputs overlap directly with sibling tools (runbooks vs gtm_find_runbooks, owners vs gtm_resolve_ownership), so the tool is not clearly differentiated from its 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?

No guidance is given on when to use this tool versus any of its 14 siblings. Given that gtm_find_runbooks and gtm_resolve_ownership overlap with outputs named in the description, the absence of any 'use this instead of X' or aggregation note leaves an agent to guess, which is a significant gap.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description's 'Find' wording agrees with those annotations (no contradiction). However, the description adds no behavioral detail beyond that—no query matching behavior, no pagination/limit effect, no return format—so annotations carry the entire burden.

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

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

The description is a single, front-loaded sentence with no filler words, making it easy to parse. It is slightly over-terse but structurally clean.

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

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

With no output schema, no parameter descriptions, and no usage guidance, this minimal description is not sufficient for confident invocation beyond the obvious first argument. An agent would not know exact-match semantics, limit behavior, or how this differs from nearby read/search siblings.

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

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

Schema description coverage is 0%, and the description never mentions the 'query' or 'limit' parameters. The agent is left to guess that 'query' is a search term and what 'limit' controls, so the description fails to compensate for the undocumented schema.

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

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

The description uses a concrete verb ('Find') and names a specific resource ('governed business-term and technical-field definitions'), so an agent can tell what the tool targets. It does not distinguish this tool from siblings such as gtm_search_catalog or gtm_get_record, so it stops short of a 5.

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

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

There is no statement of when to use this tool, when not to use it, or which sibling tools are alternatives. The one-sentence description gives no decision context for selecting it over gtm_search_catalog or gtm_get_record.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds value by listing what the inventory contains, but it does not disclose behavior such as pagination limits, default result size, or how the query parameter impacts results, which would be useful context.

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

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

The description is a single efficient sentence with no filler. It front-loads the action and directly enumerates the return contents, making every word useful.

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

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

For a simple read-only inventory tool, the description conveys the broad output categories, and annotations cover safety. However, it omits guidance on when to use it relative to lineage/ownership siblings and does not clarify parameter behavior, leaving the overall context only partially complete.

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

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

Schema description coverage is 0%, and the tool description does not explain the two parameters, 'limit' or 'query'. The names are somewhat self-explanatory, and the schema provides types and constraints, but the description adds no explicit meaning about filtering or result limiting.

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

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

The description uses a clear verb, 'Return', and identifies the resource as a measurement inventory, enumerating the included categories: assets, systems, integrations, reports, ownership, and lineage. It is informative but does not explicitly differentiate itself from siblings like gtm_trace_lineage or gtm_resolve_ownership, which also touch lineage and ownership concepts.

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

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

There is no guidance on when to use this tool versus alternatives. It does not state that it is for broad inventory overviews rather than specific lineage traces or ownership lookups, nor does it describe any exclusions or preferred contexts.

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

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

Annotations already mark the tool as readOnly, idempotent, and non-destructive, and the description's 'Return' aligns with that. The description adds useful context beyond annotations by specifying 'active responsibility relationships' and listing the four included entity types, though it does not discuss output shape or 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 a single front-loaded sentence with no filler. It states the core action, the result scope, and the active-relationship condition in minimal space, making it easy to scan.

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

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

For a simple read-only tool this is a usable minimum: an agent can call it with no parameters and know broadly what it returns. However, without an output schema or parameter guidance, the meaning of `query` and the exact response shape are left undefined, so some important context is missing.

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

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

Schema description coverage is 0% and the description does not mention `limit` or `query` at all. The parameter names hint at a result cap and free-text search, but the search target is undocumented, so the description fails to compensate for the missing schema-level explanations.

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 the verb 'Return' and names a specific resource: people, teams, agencies, and vendors with active responsibility relationships. This clearly distinguishes it from sibling tools like gtm_get_measurement_inventory and gtm_resolve_ownership without needing to inspect the schema.

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

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

The description implies use whenever an active personnel/responsibility map is needed, but it never states when to prefer this over related siblings such as gtm_resolve_ownership. There is no explicit when-not guidance or comparison to 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false, and destructiveHint=false. The description adds useful context by noting only active relationships are returned, but it does not clarify behavior when both ID and key are provided, when neither is provided, or what errors may occur.

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

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

The description is a single front-loaded sentence with no filler or redundancy. It communicates the essential operation and scope efficiently.

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

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

Given no output schema and three parameters with none required, the description omits important operational details such as the mandatory id/key relationship, how recordType factors into lookup, and expected return behavior. The sibling tool list further highlights the need for clearer selection guidance.

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

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

Schema description coverage is 0%, so the description must compensate. It explains that lookup can happen by ID or key, but it does not define what 'key' means, explain when recordType is needed, or clarify that at least one identifier is required despite no required parameters.

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

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

The description clearly identifies the verb ('Get'), the resource ('one governed record'), and the retrieval mechanism ('by ID or key with active relationships'). This distinguishes it from sibling search/context/lineage tools, which target different resources or return collections.

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 implicitly indicates use when you have a specific ID or key and need a single governed record. However, it does not explicitly say when not to use it or name alternative tools like search_catalog or get_data_definition, leaving routing decisions to inference.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context about what the listing exposes (constraints, documentation, verification state), but it does not disclose further behavioral details such as pagination, filtering behavior, or any governance-specific caveats.

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

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

A single, front-loaded sentence that names the action, resource, and output categories without redundant wording. Every phrase contributes useful 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?

The tool is simple and annotations cover safety, but without an output schema and with 0% parameter documentation, the agent is left without enough detail about what values to supply or what the response shape is. The description offers only a high-level summary of return content.

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

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

Schema description coverage is 0%, and the description does not mention 'operation' or 'platformKey' at all. The parameter names give only weak hints, and an agent cannot determine expected values, whether they are filters, or how they affect the listing. The description fails to compensate for the absent schema documentation.

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

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

The description clearly states the verb 'List' and the resource 'governed mass-change templates', while also naming the returned content categories: constraints, documentation, and verification state. This distinguishes it from sibling tools like gtm_generate_bulk_template and gtm_validate_bulk_change.

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 listing verb implies when to use it, and the resource scope is clear, but there is no explicit guidance about when to choose this over generate/validate tools or any stated exclusions. Usage context is largely inferred rather than stated.

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

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

Annotations already cover readOnlyHint, idempotentHint, and destructiveHint, so the description does not need to repeat safety. It adds useful workflow context by noting the listed updates are reviewable and that approval/application is out of scope, but it does not describe return shape, pagination, or filtering behavior 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?

The description is one concise sentence that leads with the primary action and resource, then adds the key limitation. There is no wasted text or redundant restating of the title.

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

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

For a tool with three optional parameters and no output schema, the description captures the core purpose and read-only limitation. However, it leaves important context unclear, such as what fields each returned update contains, how connectorKey affects results, and what each status value means in the reconciliation workflow.

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

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

Schema description coverage is 0%, and the description provides no explanation of limit, status, or connectorKey semantics beyond the bare schema defaults and enums. The phrase 'reviewable changes' loosely relates to status, but it does not meaningfully compensate for the missing parameter documentation.

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

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

The description names a specific verb ('List'), a specific resource ('reviewable changes detected by source reconciliation'), and explicitly scopes what the tool cannot do ('cannot approve or apply them'). This clearly differentiates it from sibling tools like gtm_validate_bulk_change or gtm_list_bulk_templates.

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

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

The description implies the tool should be used when an agent needs to review source-reconciliation changes, and it gives one exclusion: it cannot approve or apply them. However, it does not name sibling alternatives or state explicit when-to-use conditions, leaving routing partially to inference.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so no side-effect warning is needed. The description adds the subject areas the status covers but nothing about freshness, permissions, or failure behavior, leaving it at the baseline for annotation-covered safe reads.

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 short sentence that names the tool's three key outputs with no filler. Every word contributes to the meaning.

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

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

For a zero-parameter read-only status tool, the description covers the essential content areas. It could mention output shape or error conditions, but the lack of parameters and strong annotations make this a minor gap.

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

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

The tool takes zero parameters, so parameter guidance is moot. Schema coverage is effectively 100% and the description correctly implies an unparameterized status query.

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

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

States a specific verb 'Describe' and a distinct resource: the data module's enabled catalog backend, UTM integration availability, and restricted-data policy. This distinguishes it from sibling measurement/search/lineage tools, though it does not explicitly contrast with them.

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

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

No guidance on when to call this tool versus siblings or what triggers its use. The description only says what it reports; an agent must infer that a status/config check is the right occasion.

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

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

Annotations already communicate that the tool is read-only, idempotent, and non-destructive, so the description does not need to restate those guarantees. It adds a little behavioral color by listing the ownership categories, but it does not disclose anything beyond that, such as how resolution is performed or what the output shape will be. No contradiction with annotations exists.

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

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

The description is a single sentence and front-loads the action and resource before enumerating the relevant ownership roles. It is efficient and free of filler, though the list of seven roles feels a bit repetitive since they all fall under the same ownership concept.

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 undocumented optional parameters and no output schema, the description is not complete enough for an agent to know what inputs to provide or what response to expect. It does not explain whether to pass a query, a recordId, or both, nor does it clarify the return format. The read-only annotations mitigate safety concerns but do not resolve this operational gap.

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

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

The schema provides no descriptions for 'query' or 'recordId' (0% coverage), and the description does not compensate by explaining how these parameters relate to resolving ownership. It is unclear whether they are alternatives, required in combination, or how each is interpreted. The description adds no parameter-level meaning at all.

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

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

The description uses a specific verb ('Resolve') with a clear resource ('GTM ownership') and enumerates the concrete ownership roles involved: owners, operators, approvers, backups, agencies, vendors, and escalation contacts. It is clearly not a tautology and gives the agent a concrete sense of what the tool produces, though it does not explicitly differentiate from sibling tools such as gtm_get_personnel_map.

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

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

The description offers no guidance on when to choose this tool over alternatives, no exclusions, and no context such as prerequisites or typical scenarios. It simply states the capability, leaving the agent to infer when 'resolve ownership' applies; it does not even explain whether to use it instead of gtm_get_personnel_map or gtm_get_record.

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

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

Annotations already communicate readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds the searchable-scope behavior but does not explain pagination, matching semantics, result shape, or what the openWorldHint=false means in practice.

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

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

The description is a single sentence with no filler, front-loading the verb and using every phrase to communicate scope. The long list is necessary because the tool searches across many record types.

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 search tool with five optional filter parameters and no output schema, the description is too thin. It does not mention how filters narrow results, what the return value contains, or when to use a targeted sibling instead. The safe-read behavior is covered by annotations, but operational guidance is missing.

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

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

Schema description coverage is 0%, so the description needed to compensate for the five parameters. It only indirectly documents the recordTypes enum by listing its values in prose; query, limit, lifecycle, and verificationState receive no semantic explanation beyond their parameter names.

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

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

The description opens with the specific verb 'Search' and names the full catalog scope: people, teams, agencies, vendors, systems, accounts, integrations, definitions, measurement assets, runbooks, policies, and reports. This clearly distinguishes it from more targeted sibling getters like gtm_get_record or gtm_get_data_definition.

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

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

The description implies general lookup usage by listing many searchable categories, but it gives no explicit guidance on when to prefer this tool over siblings or when to use a more specific getter. There are no exclusions or routing 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered by structured data. The description adds the 'governed' qualifier and the four-level depth limit, which gives some behavioral context, but it does not disclose output shape, pagination, or any operational side effects.

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

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

A single, front-loaded sentence with no filler. It communicates the core action, the resource, the scope, and the depth limit efficiently. 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 there is no output schema and no parameter descriptions, the description is adequate for recognizing the tool's purpose but leaves gaps around what the trace result looks like and how direction/depth interact. For a read-only lineage tool this is serviceable 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 0%, so the description must compensate, and it partially does: 'upstream and downstream' maps to the direction parameter, and 'up to four levels' aligns with depth. However, recordId is not explained, and the default/combination behavior of depth and direction is left to inference.

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

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

The description uses a specific verb ('Trace') and a concrete resource ('GTM data lineage'), and it states the exact scope: governed upstream and downstream relationships up to four levels. This clearly distinguishes it from siblings like gtm_get_record and gtm_get_data_definition, which address different data concerns.

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

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

The description makes it implicit that this tool is for tracing lineage relationships, but it does not provide explicit when-to-use guidance or contrast with alternative tools. An agent can infer the use case from the wording, but there are no exclusions or sibling routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description reinforces this by saying it won't upload or change the platform. It adds useful detail about what exactly gets validated (columns, required values, allowed values, row limits), which is beyond the annotations.

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

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

The description is a single, tightly written sentence with no filler. Key behavioral constraints are front-loaded, and every phrase adds 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?

With no output schema and no parameter descriptions, the description should explain what templateKey refers to, what the CSV must look like, and what the tool returns (e.g., validation report vs. throwing errors). It is missing all of that, so an agent would struggle to invoke it correctly despite the clear high-level purpose.

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

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

Schema description coverage is 0%, so the description must explain what 'templateKey' and 'csv' mean and how they should be supplied. It does neither; it only describes the validation behavior generically, leaving the agent to guess the role of templateKey and the expected CSV format.

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

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

The description names a specific action ('Validate') and resource ('bulk-change CSV'), and lists the validation dimensions: columns, required values, allowed values, and row limits. It is clear enough to separate this from sibling tools like gtm_generate_bulk_template, though it does not explicitly name an alternative.

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

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

The phrase 'without uploading or changing a platform' implies this is a pre-flight check before an actual change, giving some context. However, it does not explicitly state when to use this tool versus siblings 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.