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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is established. The description adds scoping detail ('one exact', explicit targets) but does not disclose what the comparison output looks like or whether exact-match semantics affect the result. No contradiction with 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 one sentence, front-loaded with the action and resource, and contains no filler. It is easy to parse quickly and leaves the detailed parameter constraints to the schema where they belong.

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 schema and annotations cover parameter construction and safety well, so the agent can call the tool without missing required inputs. However, with no output schema, the description does not explain the return format or diff semantics, and it does not address how to choose between this tool and diff_versions. These gaps leave important context to inference.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description's list of object kinds aligns with the optional 'kind' parameter and reinforces exactness, but it does not add meaningful semantics beyond what the input 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?

The description uses a specific verb ('Compare') and identifies the resource and comparison scope: one exact API/event/enum/structure/widget/system between two channel/build targets. It is clear and precise, but it does not explicitly distinguish this from the close sibling diff_versions, so it does not fully earn 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 'one exact' and 'explicitly selected channel/build targets' implies this is for precise comparisons rather than discovery, but the description never says when to use this tool versus diff_versions, search_api, or get_api_history. With multiple comparison and lookup siblings, the lack of explicit routing guidance 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 establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description consistently reflects a read-only listing operation and adds that results are limited to added, removed, and structurally changed APIs, but it does not disclose pagination, limit behavior, or namespace matching details.

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

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

The description is a single, well-structured sentence. The core purpose is front-loaded, and the optional filters are appended without wasted words or redundant restatement of the tool name.

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

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

Given that the schema fully documents all parameters and the annotations cover the read-only/idempotent safety profile, an agent can invoke this tool correctly from the definition. Minor gaps remain: there is no output schema and the description does not clarify how diff_versions compares with sibling compare_api, so it is not fully 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%, with all eight parameters documented, including enums, defaults, and constraints (e.g., limit default 50/max 100, change default 'all', channel enum). The description highlights kind and namespace filters but does not add parameter-level meaning beyond the schema, so the baseline 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 uses a specific verb ('List') and resource ('APIs'), and defines the exact scope: APIs added, removed, or structurally changed between two channel/build targets. It is clear, but it does not explicitly distinguish itself from sibling tools like compare_api, so it falls short of a 5.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as compare_api, get_api_history, or list_versions. There are no exclusion conditions or alternative routing; the only pointer to list_versions appears in the schema, not in the description.

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

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

Annotations already declare the operation as read-only, idempotent, and non-destructive, so the description does not need to repeat that. It adds useful output-scoping context by describing the lifecycle events covered, but it does not disclose return format, ordering, or any other behavioral edge cases.

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, tightly worded sentence conveys the tool's core behavior without any filler. The action, resource, scope, and event types are all front-loaded and each clause carries 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 read-only history tool with fully described parameters and safe annotations, the description is largely complete. It could be slightly stronger by noting what the returned patch entries look like or explicitly mentioning optional filters, but the essentials for selecting and calling the tool are present.

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 parameter meanings are already fully documented. The description reinforces that 'name' is the exact API name and 'channel' is the selected channel, but it adds no further parameter-level detail 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 uses a specific verb ('Show'), a clear resource ('patches'), and a precise scope ('in the selected channel'). It also identifies the exact API lifecycle events that define the tool's behavior, making it easy to distinguish from sibling lookup and diff tools.

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

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

The intended use is implied: use this tool to find patches where a specific API appeared, disappeared, or changed structure. However, it does not explicitly state when to prefer this over siblings like compare_api or diff_versions, nor does it mention any exclusions.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is established. The description adds the 'resolved' concept and lists what the report includes, but it does not explain resolution behavior, error cases, or response format.

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

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

The description is a single compact sentence with no filler. It front-loads the action and resource, then efficiently lists the report 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 two-parameter, read-only reporting tool, the description combined with the schema and annotations is nearly sufficient. It explicitly names the returned information (upstream commit, entry counts, archive coverage), though a bit more detail about what 'resolved' means and the response shape would make it fully 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%, so the parameters are already well documented, including the channel enum and the version semantics. The description adds little beyond restating 'selected channel' and the notion of resolution, so it does not significantly augment 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 names a specific verb ('Report') and a specific resource ('resolved WoW dataset'), and enumerates the output dimensions: upstream commit, entry counts, and archive coverage. It is clear about what the tool does, but it does not explicitly distinguish itself from sibling tools like list_versions or diff_versions.

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

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

The description provides no guidance on when to use this tool versus alternatives, and it does not mention any exclusions or related sibling tools. The usage context is only implied by the tool name and parameter schema, not stated.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the description only needs to add scoping context. It adds 'all values and metadata in one patch' but stops short of describing return shape or any special edge-case behavior.

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

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

A single front-loaded sentence conveys resource, scope, and the channel/patch constraint with no filler or repetition.

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

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

With no output schema, the description's mention of 'all values and metadata' usefully signals the return content, and the 100% schema coverage covers the inputs. It could be slightly more explicit about the return structure, but it is complete enough for a read-only enum lookup.

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 all three parameters are already documented with descriptions, enums, and constraints (e.g., channel not inferred). The description repeats the patch/channel idea but adds no new parameter-level meaning beyond the schema.

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

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

The description names the specific verb, resource ('WoW enumeration'), and scope ('in one patch in the selected channel'), which clearly distinguishes it from comparison or lookup siblings like diff_versions and lookup_resource.

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 'exact ... in one patch in the selected channel' gives clear context for single-enumeration lookups, and the contrast with comparison/diff siblings is implied by the wording. However, it does not explicitly state when not to use this tool or name an alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description does not need to restate safety. It usefully adds that the result is exact and includes payload and restrictions for a single patch, but it does not describe edge cases like 'latest' resolution or not-found behavior.

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

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

A single front-loaded sentence conveys the resource, result contents, and scope with no filler or repetition. 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 simple read-only lookup with fully documented parameters and safety annotations, the description covers what the tool returns and its scope. It could mention how 'latest' is handled in the version parameter, but the schema already covers that, so nothing critical 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 coverage is 100%, with name, channel, and version all described. The description indirectly maps to channel/version via 'selected channel' and 'one patch' but adds no parameter-level detail 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?

The description names the exact resource (WoW frame event) and what is fetched (event, payload, restrictions), plus scoping to one patch and channel. This clearly differentiates it from sibling tools that target namespaces, datasets, APIs, resources, or migrations.

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

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

No guidance is given about when to use this tool instead of siblings like lookup_api, search_api, or compare_api. There are no alternatives, exclusions, or prerequisites mentioned, leaving the agent to infer usage from the word 'event' alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds useful provenance and non-inference context, but does not describe output shape, failure behavior, or how version resolution works 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 focused sentences with no filler. The core action and scoping are front-loaded, and the caveat about non-inference 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?

Adequate for a read-only, idempotent lookup with useful annotations, but there is no output schema and the description does not explain what the returned guidance looks like or what happens when no guidance is found. Version/channel interaction is also left implicit.

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 67%, with channel and version already documented. The tool description adds meaning by mapping name to 'exact legacy API name' and version to 'target build', but it does not address the channel parameter or further clarify accepted name formats.

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

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

States a specific verb and resource: 'Get ... community migration guidance', and further scopes it to an exact legacy API name and target build. The second sentence, 'This is not inferred from catalog absence', helps differentiate it from catalog-driven lookup/search 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?

Provides clear context: use it when you have an exact legacy API name and target build and need separately sourced community migration guidance. It also draws a boundary by saying guidance is not inferred from catalog absence, but it does not explicitly name sibling alternatives or state when not to use them.

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, and the description's 'List' aligns with them. It adds scoping context (one patch, selected channel) but does not disclose output format, pagination, or potential none/empty results; the annotation coverage keeps this at a 3.

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 16-word sentence that front-loads the action and resource, then packs the relevant scope constraints with no filler. Every phrase 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 read-only listing tool with three well-documented parameters, this is largely complete: it states what will be returned (functions/events/types/systems) and the exact scope. The only gaps are minor—no mention of return shape, error cases, or behavior when nothing is found—and no output schema exists to fill them.

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

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

Schema description coverage is 100% and already documents namespace, channel, and version. The description loosely echoes the parameters ('exact namespace', 'one patch', 'selected channel') but adds no parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

Description opens with a specific verb ('List') and names the exact resource categories (functions, events, types, systems) plus scoping constraints (exact namespace, one patch, selected channel). This clearly distinguishes it from single-entity siblings like get_enum/get_event and from lookup/search tools.

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

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

The description implies when the tool is appropriate by emphasizing an exact namespace and single patch/channel, but it never states when to prefer it over lookup_api/search_api or other siblings. No alternatives or exclusionary guidance is provided.

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

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

Annotations already declare readOnlyHint and idempotentHint, and the description's 'Get' is consistent with those. It adds useful context that the result is pinned to a single patch/channel, but it does not describe return shape, pagination, or any special caveats beyond what annotations provide.

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 states the action, resource, and scope without filler. Every phrase carries information: widget type, public methods, one patch, selected channel.

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 fully documented schema, read-only annotations, and a description that states both the returned content (widget and public methods) and version/channel scope, the definition is sufficient for a lookup tool. There is no output schema, but the expected output is clear enough from the description and tool name.

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

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

Schema description coverage is 100%, so the parameters are already fully documented with names, examples, defaults, and enum constraints. The description adds no parameter-level meaning beyond the schema.

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

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

The description opens with the verb 'Get' and names a precise resource: a ScriptObject or FrameXML intrinsic widget plus its public methods. It also constrains the scope to one patch in the selected channel, which visibly separates it from sibling tools like compare_api, diff_versions, and generic lookup_api/resource tools.

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

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

The phrasing implies the tool is for retrieving widget API methods at a specific version/channel, but it never states when to prefer it over alternatives or when not to use it. No sibling tool or exclusion is mentioned, so the agent has to infer selection from the word 'widget.'

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, covering the safety profile. The description adds a minor behavioral detail by stating 'Use this before data queries,' implying a sequencing constraint. It also gives a sense of what the operation returns (patches, builds, dates, commits), but this overlaps with purpose clarity rather than surfacing new behavioral traits like auth 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?

The description is two sentences and wastes no words. The main purpose is front-loaded, and the usage directive is a single closing sentence. Every sentence contributes meaningful guidance.

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

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

For a simple read-only listing tool with one optional parameter, full schema coverage, and rich annotations, the description is largely sufficient. It names the kinds of data returned and states when to call it. It could be slightly stronger by referencing sibling tools like diff_versions for comparison tasks, but that is a nicety rather than a critical gap.

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

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

Schema description coverage is 100%, and the channel parameter already has a clear description ('Game channel; never inferred from a version number') plus an enum. The description's phrase 'or filter by channel' reinforces optionality but adds no new syntax or format details beyond the schema. 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 tool's function: 'Discover bundled patches, exact client builds, dates, and source commits for both channels, or filter by channel.' It uses a specific verb and resource, and the 'or filter by channel' clause adds operational scope. However, it does not explicitly name or distinguish sibling tools such as diff_versions or get_api_history, so it falls short of full uniqueness.

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 explicit timing guidance: 'Use this before data queries.' This tells the agent when to invoke the tool in a workflow. It does not mention when not to use it, nor does it name alternatives, so it lacks exclusionary 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so this is clearly a safe read operation. The description adds behavioral scoping: results are exact, patch-bound, and channel-bound. It does not disclose what happens when no match exists or what the returned object looks like, but the annotation safety profile covers the main behavioral risk.

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 with no filler, front-loading the verb and object ('Look up an exact...') before the scoping details. 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 100% schema coverage and read-only annotations, the agent can correctly populate required fields. But with no output schema and a large sibling list, the description does not explain the return shape or how this tool relates to specialized lookup/search siblings, leaving a meaningful gap for confident selection.

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

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

Every parameter (kind, name, channel, version) is documented in the schema with descriptions and enums, so schema coverage is 100%. The description contributes no extra parameter meaning beyond restating the artifact categories, so it hits the schema-documented baseline of 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 names a concrete action ('look up') and a specific object ('exact WoW API function, method, event, enum, structure, widget, or system') and narrows scope to 'one patch' and the 'selected channel'. It is clear, but it does not explicitly distinguish lookup_api from specialized siblings like get_enum, get_event, or search_api, so full differentiation is left to the agent.

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?

'Exact' implies the tool is for precise known-name lookups rather than fuzzy discovery, and the patch/channel constraint gives clear context. However, it never states when to prefer search_api or a specialized get_* sibling, and it offers no exclusion criteria, so guidance is only implicit.

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

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

Annotations already cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'look up' aligns with read-only behavior. It adds useful context about the reviewed/community nature and the included coverage fields, but does not disclose output format, pagination, errors, or other operational behavior 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?

A single, front-loaded sentence immediately states the action and resource, then packs the distinguishing output attributes into a short modifier list. There is no filler, repetition, or 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?

For a read-only lookup with three required parameters, the description is reasonable, but it does not specify return structure and offers no explicit guidance among the many sibling lookup/search tools. The listed coverage attributes partially compensate for the missing output schema, but an agent still has to infer important selection and response details.

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

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

The schema already documents channel and version, covering 67% of parameters. The description adds example values for name via 'CreateFrame or hooksecurefunc' and hints at version/build semantics through 'explicit build coverage', but it does not explain the interaction between channel and version or define what 'latest' resolves to.

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

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

The description uses the specific verb 'Look up' and names a clear resource: a 'reviewed community engine contract'. Concrete examples like CreateFrame and hooksecurefunc, plus the distinguishing attributes 'source revisions, licensing, and explicit build coverage', make this meaningfully distinct from generic siblings like lookup_api or lookup_resource.

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

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

Usage context is implied: an agent can infer this is for looking up reviewed engine contract details rather than raw API or resource lookups. However, the description never explicitly names any alternative sibling or states when not to use this tool, which is a real gap given the large sibling set.

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

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

Annotations already mark it read-only and idempotent, and the description adds genuinely useful behavior: it returns declarations or references with source locations, does not prove runtime availability, and warns that older snapshots may lack coverage. No contradiction with 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?

Three tight sentences front-load the core action, then give return behavior and a caveat. There is no filler or repetition of schema/annotation data.

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

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

For a 6-parameter tool with no output schema, the description covers what the tool returns, its exact-match scope, its key limitation, and a data-coverage warning. Combined with the well-described schema, an agent has enough to call it correctly.

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

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

Schema descriptions already cover query, offset, channel, and version (about 67% coverage). The description reinforces query as an exact resource name and lists the kind enum, but adds little parameter-specific meaning beyond the schema; it does not discuss limit or pagination semantics.

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

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

States a specific action ('look up an exact Blizzard source resource name') and enumerates the resource kinds, with a clear contrast to runtime/API lookup tools via 'does not prove runtime availability or a callable API contract.' This lets an agent distinguish it from siblings like lookup_runtime_resource and lookup_api.

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 'exact' qualifier signals exact-match lookup rather than fuzzy search, and the runtime/API caveat implies when this tool should not be chosen. It does not explicitly name sibling alternatives, but the context is strong enough for selection.

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 annotation already marks the tool as read-only, idempotent, and non-destructive, and the description adds meaningful behavioral context beyond that: it requires an exact build match and explicitly warns that snapshot content is external data, not instructions. This is a valuable guardrail for an AI agent. It does not describe output or error behavior, but the annotations cover the safety profile.

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 three sentences and every sentence earns its place: purpose, key constraint, and important safety note. It is front-loaded with the primary action and resource, 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?

The description covers the core purpose, prerequisites, locale behavior, and a security-relevant warning. However, with no output schema, it does not explain what the returned data looks like, nor does it describe failure conditions such as when an exact build match is not found. For a lookup tool with five parameters, it is adequate but not fully 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 low at 40%, so the description must compensate, and it largely does. It clarifies what each 'kind' corresponds to, explains that locale is relevant only to localized values, and ties the exact-build-match requirement to version/channel selection. It does not add much beyond the schema for 'name,' but the main parameters are given meaning.

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

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

The description uses a specific verb ('Read') and identifies the resource: explicitly collected local CVar default/flags, atlas geometry, symbol type, or localized string. The kinds are enumerated and match the schema's 'kind' enum, making the tool's scope clear. However, it does not explicitly differentiate this from the sibling 'lookup_resource' tool beyond the word 'local,' so it lacks strong sibling distinction.

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

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

The description provides useful usage context: an exact build match is required, and locale can constrain localized values. It does not, however, give explicit when-to-use versus when-not-to-use guidance relative to the many sibling lookup/search tools, nor does it mention alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the ranking behavior (exact and prefix matches first) and the scoping to a single patch and channel, which is useful. However, it does not disclose return format or pagination behavior, which would add more value 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 two concise sentences with zero waste. The core purpose and ranking behavior are front-loaded, and it does not repeat information already present in the schema or annotations.

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 covers all parameters and annotations cover safety, the description is adequate but sparse. It does not describe the result format (e.g., list of matches with documentation excerpts) or any limitations beyond the ranking. For a search tool with no output schema, a bit more detail on return structure would improve completeness, but it is not critically deficient.

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 all parameters are documented in the schema itself. The description adds minimal parameter-specific meaning, only echoing the scoping (patch, channel) without introducing new semantics. With high schema coverage, the baseline 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 'search' and the resource: API names and official documentation text, scoped to a patch and channel. It also mentions the ranking behavior (exact and prefix matches first), which distinguishes it from generic search tools. This is specific and differentiates it from siblings like search_resources.

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

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

The description gives clear context on what it searches (within a patch/channel) but provides no explicit guidance on when to use this tool over alternatives, nor any exclusions. There is no mention of 'use instead of X' or when not to use it, leaving the agent to infer the appropriate context from the scope.

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 readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond the annotations: it returns declarations or references with source locations, excludes runtime guarantees, and warns about incomplete older snapshots. This is useful behavioral disclosure without contradicting 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?

Three dense, purposeful sentences. The first sentence states the action and scope immediately; the second and third add necessary caveats about runtime availability and historical coverage. No filler or repetition of schema details.

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

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

For a read-only search tool with six parameters and no output schema, the description explains what results contain, what they do not prove, and when coverage may be missing. Pagination is handled in the offset parameter description, so the overall package is nearly complete, though the description itself could have briefly mentioned offset pagination for extra robustness.

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 provides meaningful descriptions for query, channel, version, and offset, covering 67% of parameters. The description's enumeration of resource kinds mirrors the kind enum and adds little parameter-level meaning beyond that. It does not compensate for the missing descriptions of kind and limit, but the schema gives sufficient guidance overall.

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

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

States a specific verb and resource: searching Blizzard source resource names (symbol, template, mixin, frame, CVar, atlas). It also distinguishes itself from sibling runtime/API lookup tools by explicitly saying it returns source declarations/references and does not prove runtime availability.

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?

Clearly signals when not to use the tool: it does not prove runtime availability or a callable API contract, and older snapshots may lack resource coverage. It does not explicitly name alternatives like lookup_runtime_resource or search_api, but the when-not conditions are clear enough to route an agent.

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

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

Annotations already disclose readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to cover safety behavior. It adds some behavioral context by specifying that the search is restricted to one patch in the selected channel, but it does not mention output shape, pagination, or result contents, which remain undocumented.

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

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

The description is a single, front-loaded sentence that starts with the action and immediately identifies the restriction categories and scope. It contains no filler, repeated schema information, or unnecessary clauses.

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 read-only, idempotent search tool with fully described parameters, the description and schema together give an agent enough to invoke it correctly. There is no output schema, so a little more detail about what the returned API matches look like would improve completeness, but the current definition is still largely 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?

Schema description coverage is 100%, so the parameters are already documented with channel, version, limit, and query semantics. The description does not add further parameter-level detail beyond what the schema provides, making the baseline score of 3 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 names a specific action ('Find') and resource ('APIs carrying ... restrictions') with concrete restriction categories and scope ('in one patch', 'selected channel'). It is clearly distinct from generic search tools, though it does not explicitly contrast itself with sibling tools like search_api or search_resources.

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

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

The description implies the usage context: use this when you need APIs with combat, secret-value, taint, secure-code, or unit-aura restrictions in a single patch. However, it gives no explicit when-not-to-use guidance and does not name alternative sibling tools or conditions that should route to them.

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