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

The description discloses the key behavioral trait: advancing subscription cursors, which implies state changes and explains why readOnlyHint=false and idempotentHint=false. It adds useful context beyond the annotations, such as the external polling nature and the fact that checking advances state.

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

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

Two short sentences deliver the core action, the side effect, and parameter behavior with no filler. The most important behavioral detail (polling and cursor advancement) is front-loaded.

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

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

For a tool with a single optional parameter and no output schema, the description covers the necessary invocation details: what the tool does, what the optional parameter means, and how to check all subscriptions. It does not describe the response shape, but the absence of an output schema lowers that expectation.

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 parameter schema has no description and 0% coverage, so the description carries the burden. It explicitly explains the meaning of omitting subscriptionID and implies that providing it checks a single subscription. This is meaningful guidance for the one optional parameter.

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

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

The description uses a specific verb ('Poll WCL') and names the resource ('new reports') and the side effect ('advance subscription cursors'). It clearly differentiates this from sibling tools like list_character_subscriptions by emphasizing polling and cursor advancement rather than just listing subscriptions.

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 concrete usage context: omit subscriptionID to check all subscriptions. It does not explicitly name alternatives or exclusions, but the semantics are clear enough for an agent to know when to call this tool versus the read-only listing or subscription management tools.

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

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

The description adds 'locally persisted', clarifying that this only affects local state and not the server. The destructiveHint=true annotation aligns with 'Remove', so there is no contradiction.

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

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

A single, precise sentence with no filler or redundant phrasing. It states the action and scope immediately.

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 mutation tool, the description provides enough context: what is removed, where it is removed from, and the local scope of the effect. No output schema exists, so return details are not necessary.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is nothing for the description to add about parameters. The baseline of 4 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 ('Remove') and a specific resource ('locally persisted active-character default'). This clearly distinguishes it from sibling tools like set_active_character and get_active_character.

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

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

The description implies usage: clear the local default when you no longer want a persisted active character. However, it does not explicitly mention alternatives or state when not to use it, leaving some inference to the 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 provide readOnlyHint, idempotentHint, and destructiveHint, so safety is well covered. The description adds useful behavioral context beyond annotations by noting the value is 'locally persisted' and that the active character may not be configured, implying a possible absence result. It does not detail the exact return shape when unset, but the conditional phrasing partially covers that.

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

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

One sentence with no wasted words, front-loaded with the action and resource. It is appropriately sized for a zero-parameter getter.

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, zero-parameter, read-only getter with rich annotations, the description is mostly complete: it states what is returned and the configuration condition. The only minor gap is not explicitly describing the fallback behavior when no active character is configured, though 'if one is configured' strongly implies it.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The description correctly focuses entirely on the return value rather than inputs.

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 ('Return'), identifies the resource ('the locally persisted active character'), and adds a scope condition ('if one is configured'). It clearly distinguishes itself from mutating siblings like set_active_character and clear_active_character.

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

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

The description implies when to use the tool by defining it as the getter for the active character, but it does not explicitly state when to choose this over alternatives or mention related tools such as get_character_summary. The usage context is clear but not fully spelled out.

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, openWorldHint, idempotentHint, and non-destructiveness. The description adds behavioral context beyond those annotations: it says results are 'bounded' and that playerID is interpreted as a WCL targetID. This is useful information about output limits and parameter mapping not present in 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 only two sentences with no filler. It front-loads the core purpose and then provides a targeted parameter caveat, making it easy to scan and 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?

With 11 parameters, no output schema, and a directly overlapping sibling tool named get_buff_uptime, the description is too sparse. It does not explain what the returned buff-uptime evidence looks like, what 'bounded' means in practice, or how this tool differs from get_buff_uptime. An agent would likely need external knowledge to invoke it with full confidence.

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 64%, so the schema already documents most parameters. The description adds a small clarification about playerID being applied as WCL targetID, but this is largely redundant with the schema's own note that the tool maps it to the correct source/target filter. It does not meaningfully explain the undocumented parameters such as abilityID, translate, maxEntries, or maxPayloadBytes.

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

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

The description clearly states a specific verb and resource: 'Get bounded buff-uptime evidence on a player.' It is understandable and identifies the core function, though the word 'bounded' is somewhat vague and it does not explicitly distinguish this tool from the similarly named sibling get_buff_uptime.

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

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

There is no guidance about when to use get_buffs versus get_buff_uptime or any alternative tool. The description mentions playerID handling but does not provide selection criteria, exclusion conditions, or context for choosing this tool over siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the description does not need to repeat that. The only behavioral addition is 'bounded target semantics,' which is vague and does not explain what gets bounded, how, or what consequences that has for results.

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, so it is concise and front-loaded. But it is so terse that it sacrifices substance; the phrase 'bounded target semantics' carries unexplained meaning that should be unpacked.

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 11 parameters, no output schema, and a description that only calls itself a compatibility alias, the definition is incomplete. An agent cannot determine what 'bounded target semantics' means for valid input combinations, what the response contains, or how the tool relates to the sibling get_buffs in practical use.

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

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

Schema description coverage is only 64%, leaving parameters like abilityID, translate, maxEntries, and maxPayloadBytes without schema descriptions. The tool description adds no parameter guidance whatsoever, so it does not compensate for the coverage gaps.

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 title and description identify buff uptime as the domain, and 'compatibility alias for get_buffs' provides a rough sense of purpose. However, 'bounded target semantics' is never explained, so an agent cannot tell what this tool actually computes or how its output differs from get_buffs.

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 get_buff_uptime versus get_buffs. It implies an alias relationship but does not state whether one should be preferred for bounded targets, which target constraints apply, or when to choose 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 provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds a useful behavioral claim that playerID is applied as WCL sourceID, but 'bounded' is left unexplained and no return or pagination behavior is disclosed.

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

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

The description is only two sentences and stays focused, but it is extremely terse for an 11-parameter tool. The first sentence is vague, while the second sentence is useful but narrow. It is concise, but it sacrifices necessary specification.

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

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

This is a complex tool with 11 parameters, no output schema, and many sibling tools, yet the description provides almost no context about result content, scope, or bounding behavior. An agent would need to inspect schemas or sibling tools to understand what 'bounded cast evidence' actually returns.

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 states that playerID 'maps it to the correct source/target filter,' so the description's playerID sentence adds little new meaning. With 64% schema coverage, parameters like abilityID, translate, maxEntries, and maxPayloadBytes lack descriptions that the tool description does not compensate for.

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

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

The description says 'Get bounded cast evidence,' which essentially restates the tool name with vague modifiers. It does not explain what a cast is, what report/fight/player scope is covered, or how this differs from siblings like get_character_casts or get_events. The playerID sentence adds parameter detail, not purpose clarity.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention get_character_casts, get_fight_events, or other sibling tools, and no selection conditions are provided. The agent is left to infer when 'bounded cast evidence' is the right choice.

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?

Beyond the readOnly/idempotent annotations, the description adds meaningful behavioral context: it will automatically discover recent reports, and results are 'bounded' and 'best-effort,' implying partial or size-limited data. It does not detail failure modes or authorization edge cases, but the annotations already cover the safety profile adequately.

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, appropriately front-loaded sentence that conveys the action, scope, and key behavior without wasted words. The phrase 'bounded, best-effort' is slightly jargon-heavy but does not add length or obscure the main purpose.

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

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

This tool has 8 parameters, no output schema, and very low schema description coverage, so the description must carry more weight. It explains the high-level purpose but not the report selection mechanism, output shape, required identifiers, or how the optional parameters affect results. The definition is not complete enough for reliable autonomous invocation in ambiguous cases.

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

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

Schema description coverage is only 25%, so the description needs to compensate, but it only vaguely hints at parameters: 'one character' suggests name, 'bounded' suggests maxEntries/maxPayloadBytes, and 'across recent reports' suggests limitReports. It does not clarify serverRegion, accessMode, contentType, or how the parameters interact, leaving an agent under-informed for a tool with 8 mostly undocumented 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 names a specific verb/action (discover and return) and a specific resource (bounded, best-effort cast evidence for one character across recent reports). It clearly distinguishes itself from sibling tools like get_casts, which are more about casts within a specific report or fight context.

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 clearly suggests a use case: when you want cast history for a single character pulled from multiple recent reports, without needing to specify a particular report or fight. However, it does not explicitly state when not to use it or mention alternatives such as get_casts, so it falls short of full 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 readOnly, openWorld, idempotent, and non-destructive, so the bar for additional behavioral disclosure is lower. The description adds 'bounded, best-effort' and 'across those reports', which usefully signal incomplete or best-effort results. It does not disclose pagination or rate limits, but annotations cover the key 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 a single sentence with no redundant phrases. 'Discover recent reports' is front-loaded, and 'bounded, best-effort' packs important qualifiers compactly. It is appropriately concise, though slightly ambiguous grammar ('across those reports') costs it a perfect score.

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 eight parameters, no output schema, and many sibling tools, the description needs to specify required inputs and return shape; it does neither. It never mentions serverRegion, contentType, or how 'recent' is determined, so an agent must infer invocation details. Safe annotations reduce risk but do not resolve parameter and response ambiguity.

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

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

Schema description coverage is only 25% (just server and accessMode have descriptions), and the tool description mentions no parameters, not even the character name. The word 'bounded' vaguely hints at limit-related params but does not explain maxEntries, limitReports, maxPayloadBytes, contentType, or serverRegion. This fails to compensate for low schema coverage.

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

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

The description names a concrete result ('death evidence for one character') and a mechanism ('across recent reports'), distinguishing it from fight-scoped death tools like get_deaths. The title reinforces the intent. This is specific enough for an agent to understand the tool's core purpose.

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

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

No explicit when-to-use or alternative guidance is provided. The phrase 'Discover recent reports' implies historical aggregation across reports, but there is no mention of when to prefer this over get_deaths or other character-scoped tools. Usage context is only implied, 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 mark the tool read-only, open-world, idempotent, and non-destructive. The description adds useful behavioral context by explaining character resolution, the active-character fallback, and the summarized output scope. No contradiction with 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 the main purpose front-loaded and the active-character behavior stated without filler. Every sentence adds value.

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

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

Given the strong annotations and the tool's relatively simple purpose, the description covers the key resolution behavior and the content of the summary. It does not detail the exact output shape, but there is no output schema, and the stated summary scope is reasonably sufficient for invocation.

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

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

The description adds important meaning by clarifying that identity fields can be omitted to use the active character, which helps with the four-parameter schema where none are required. However, schema description coverage is only 50%, and the description does not fully compensate for the undocumented meaning of name and serverRegion.

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 gives a specific verb and resource: resolving a character and summarizing its recent report availability and content types. It conveys a clear function, though it does not explicitly contrast the tool with siblings such as get_recent_reports or get_player_analysis_context.

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

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

The description implies usage through the resolution and summarization framing, and it provides one concrete invocation guideline: omit all identity fields to target the active character. However, it does not state when to prefer this tool over related sibling tools or when to avoid it.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior. The description adds some useful context by describing the payload contents and the 'bounded' nature of the events, but it does not explain what 'bounded' means, how pagination works, or what the returned event shape looks like.

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 verb, resource, scope, and contents efficiently, making it easy for an agent to parse quickly.

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

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

The description gives enough to understand the purpose and primary input, and there is no output schema, so explaining the return concept is helpful. However, with seven parameters and no explicit guidance about required fields, output format, or the meaning of 'bounded', the description is only minimally complete for a complex tool.

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

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

Schema description coverage is only 57%, so the description should compensate for less-documented parameters like playerID, translate, and maxPayloadBytes. It does not: the only parameter-related addition is 'one player source', which merely restates that playerID targets a single player.

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

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

The description uses a specific verb ('Get') and resource ('CombatantInfo events') and clarifies scope with 'for one player source'. It also names the content type (gear, talents and player state), which distinguishes it from the many sibling get_* 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 usage context is implied: use this when you need combatant snapshot data for a single player source. However, it does not explicitly say when not to use it or name any alternative tool, so the agent must infer routing from the tool name and resource.

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/openWorld/idempotent/non-destructive, so the bar for extra value is lower. The description adds 'bounded' (capacity/payload limits) and clarifies that playerID is interpreted as the WCL sourceID, which is useful behavioral context. 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?

Two short sentences front-load the core purpose and then give the single most important parameter clarification. There is no filler or repetition of schema 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 definition is adequate for a read-only query tool, but with no output schema and 11 parameters it should at least sketch what 'evidence' looks like or how the bounds apply. The description leans heavily on the schema and annotations and leaves the return shape 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?

The input schema already documents most parameters with 64% coverage, and parameter names like abilityID, maxEntries, and maxPayloadBytes are reasonably self-explanatory. The description adds value by confirming that playerID is applied as sourceID, and 'bounded' hints at the output limits, but it does not systematically clarify the remaining undocumented parameters.

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

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

The description uses a specific verb-resource pair ('Get bounded damage-done evidence') and the name/title reinforce it. However, it does not differentiate from siblings like get_fight_damage or get_damage_taken, so it stays one step below full clarity.

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 when-to-use guidance is given. The description does not state when to prefer this over get_damage_taken, get_fight_damage, or get_fight_events, and it does not give exclusions. The only contextual hint is the playerID mapping, which is more parameter clarification than usage direction.

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 some real context ("bounded" result set, WCL table semantics mapping playerID to sourceID), but says nothing about return shape, pagination, or how maxEntries/maxPayloadBytes truncate results.

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

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

Two short sentences with no filler, and the resource is front-loaded. It is efficient, though the second sentence is dense WCL jargon that could be clearer.

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 an 11-parameter tool with no output schema and a nearly identical sibling, the description is far too thin: it omits the distinction from get_fight_damage_taken, filtering/scope behavior, and any notion of what the bounded result contains.

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 64%, above the baseline threshold, and the description does add a meaningful semantic note that playerID is mapped to sourceID for the selected player perspective. However, it says nothing about abilityID, translate, maxEntries, or maxPayloadBytes, so it only partially compensates for the uncovered 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 names the resource (damage taken) but wraps it in vague phrasing ("bounded damage-taken evidence") and never distinguishes it from the near-identical sibling get_fight_damage_taken or from get_fight_damage/get_damage_done. An agent cannot tell from this text which damage-taken variant to pick.

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 when-to-use guidance, no prerequisites, and no named alternative despite three closely related siblings in the toolset. The second sentence reads as a parameter caveat rather than routing guidance, leaving selection entirely 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, idempotentHint, openWorldHint and non-destructive, so the safety profile is covered. The description adds some domain context ("bounded", and that WCL table semantics require playerID as sourceID), which is real behavioral insight beyond the annotations, but return shape and pagination/truncation behavior are unaddressed.

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

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

Two short sentences with no padding, and the core purpose is front-loaded. The WCL jargon is dense but compact rather than wasteful.

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 an 11-parameter tool with 64% schema coverage and no output schema, the description is too thin: it never explains what a death record contains, how results are limited or ordered, or the role of abilityID/time bounds, leaving key gaps unfilled.

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 64%, so the schema documents most parameters itself (including that playerID maps to the correct source/target filter). The description reinforces that playerID is used as sourceID for the chosen perspective, but adds no syntax or meaning for the undocumented parameters such as abilityID.

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 gives a verb ("Get") and a loosely-named resource ("bounded death evidence"), but "death evidence" is vague and does not clearly say it returns death events for a report/fight. It does nothing to distinguish this from the sibling get_character_deaths.

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 versus the many sibling event tools (get_character_deaths, get_fight_events, get_events). The one contextual note is about which actor field to supply, not when the tool is the right choice.

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, openWorldHint, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds useful context via 'bounded' and clarifies that playerID is mapped to WCL targetID, but it does not explain the exact meaning of 'bounded' or describe response behavior. 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 two short sentences with no filler. The main purpose is front-loaded, and the second sentence adds a high-value parameter clarification. Every part 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, the description leaves 'debuff evidence' undefined: it does not say what the tool returns, how 'bounded' is enforced, or how fields like maxEntries and maxPayloadBytes affect output. With 11 parameters and no output schema, a minimal two-sentence description is not complete enough for an agent to fully anticipate the tool's behavior.

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

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

Schema coverage is 64%, so the schema already documents the meaning of most parameters. The description adds one valuable clarification: 'playerID is correctly applied as WCL targetID,' which goes beyond the schema's generic 'maps it to the correct source/target filter.' However, it does not compensate for the undocumented parameters like abilityID or translate, and several parameters rely entirely on their schema entries.

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

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

The description states a clear action and resource: 'Get bounded debuff evidence on a player.' The verb 'Get' and noun 'debuff evidence' make the core purpose apparent, and the phrase 'on a player' scopes it to a player context. It doesn't explicitly name sibling alternatives like get_buffs, but the debuff focus is enough to distinguish it from most siblings.

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

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

The description gives no explicit guidance on when to choose this tool over alternatives such as get_buffs, get_dispels, or get_deaths. It implies a player-focused debuff query, but does not state exclusions, preferred conditions, or how it differs from related tools. An agent would have to infer usage mainly from the tool name.

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

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

Annotations already declare this as read-only, idempotent, and non-destructive, so the description only needs to add behavioral context. It contributes 'bounded' results and clarifies that playerID maps to the WCL sourceID, both useful; however, it does not describe return shape, pagination, or other runtime behaviors.

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 brief and front-loaded with the core action. Two short sentences contain no filler, though the term 'bounded' is compressed and could be expanded slightly for clarity.

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

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

For a tool with 11 parameters and no output schema, a one-line description is insufficient. It fails to mention what the dispel evidence contains, the filtering model, or what 'bounded' means practically, leaving an agent to guess about behavior and return values.

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

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

With 64% schema coverage, the schema handles most parameters, and the description adds a meaningful refinement by specifying that playerID is applied as the WCL sourceID, extending the schema's 'source/target filter' note. It gives only a weak hint about the undocumented bound-related parameters, leaving abilityID, translate, maxEntries, and maxPayloadBytes without added semantic explanation.

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 identifies the tool's action and resource: 'Get bounded dispel evidence' clearly indicates a read operation for dispel-related data. It is distinct from sibling tools like get_interrupts or get_casts by the dispel resource, though it does not explicitly compare itself to alternatives.

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

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

The description offers no guidance on when to choose get_dispels over sibling tools or when not to use it. It states a parameter behavior ('playerID is correctly applied as WCL sourceID') but no usage context, exclusions, or 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 establish read-only, idempotent, non-destructive behavior. The description adds valuable behavioral context beyond that by disclosing that private parses require user authorization and includePrivateLogs=true. This is useful and not already encoded in 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?

Two sentences carry the core purpose and the key edge case. The purpose is front-loaded and every sentence earns its place without repetition or fluff.

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

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

With 9 parameters, low schema coverage, and no output schema, the description is too thin to fully support correct invocation. It does not explain which parameters are needed together, how encounterID and zoneID interact beyond 'exactly one', or what the response looks like. The auth caveat is helpful but incomplete for a tool of this complexity.

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

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

Schema description coverage is only 22% across 9 parameters, so the description needs to compensate. It only adds clarity for the encounter-or-zone constraint and the includePrivateLogs/auth relationship; most parameters such as metric, difficulty, serverRegion, and accessMode remain undocumented in both schema and description.

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

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

The description states a specific verb and resource: get WCL rankings for one character and exactly one encounter or zone. This clearly distinguishes the tool from sibling tools focused on fights, deaths, casts, or healing.

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

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

The description gives clear context for when to use this tool: when rankings for a single character tied to a single encounter or zone are needed. It also notes the private-parse auth requirement. It does not explicitly name alternatives or exclusions, but the scope is clear enough for an agent to select it appropriately.

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, openWorldHint, idempotentHint, and destructiveHint false. The description adds meaningful behavioral details beyond those annotations: fight time bounds, max events/pages, a byte budget, and pagination cursor semantics. It is consistent with the annotations, and for a read-only paginated tool this is strong disclosure.

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

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

Three short sentences with the core purpose first, followed by constraints and the pagination instruction. There is no filler, no repetition of schema fields, and every sentence contributes meaning. It is appropriately sized for the tool's primary behavior.

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

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

Given 17 parameters, low schema coverage, no output schema, and a large sibling family, this description is too thin. It communicates the bounded pagination model and safety profile, but an agent cannot confidently determine how the filter parameters interact, how truncation by maxPages/pageSize/maxPayloadBytes is signaled, or when this tool should be chosen over get_fight_events. The complexity demands more guidance.

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

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

Schema description coverage is only about 41%, so the description needed to compensate for many undocumented parameters. It does map a few concepts to parameter groups: fight time bounds to startTime/endTime, max events/pages to maxEvents/maxPages, byte budget to maxPayloadBytes, and cursor to nextPageTimestamp. But it says nothing about dataType, sourceID/targetID/abilityID filters, translate, includeResources, or accessMode, leaving major parts of the parameter surface unexplained.

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

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

Names a specific operation: retrieving a bounded event window with WCL pagination, and states concrete constraints such as fight time bounds, max events/pages, and a byte budget. It is clearly about fetching bounded combat events, but it does not explicitly differentiate itself from the similarly named get_fight_events sibling or explain how bounded pagination differs from that 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?

Gives one actionable usage instruction: continue using pagination.nextPageTimestamp as a cursor, which is useful for callers making repeated paginated requests. However, it never says when to prefer this tool over get_fight_events, get_casts, or the other event-specific siblings, nor does it state when not to use it.

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

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

Annotations already establish read-only, idempotent, non-destructive, and open-world behavior, so the description's burden is lower. It adds that this is a compatibility alias and that results are somehow bounded by source, but the vague phrase does not specify what source boundary applies or how behavior differs from get_damage_done. There is no contradiction with annotations, yet the added behavioral insight is thin.

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

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

The description is a single tightly worded sentence with no fluff, front-loading the 'compatibility alias' identity before the qualifier. It is concise and structurally efficient, though it sacrifices clarity with the undefined term 'bounded source semantics.'

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 11 parameters and no output schema, the description is too thin. It never states what response shape to expect, whether this is deprecated, or what source boundary is applied, and it does not explain how the alias maps to get_damage_done's semantics. An agent cannot confidently decide between this and get_damage_done from the description alone.

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

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

Schema coverage is only partial (64%), yet the description contributes no parameter-level details. It does not explain how fightID, startTime/endTime, or maxEntries should be used, nor what 'bounded source semantics' means in terms of parameters. The agent must rely on schema names and enums and guess how the qualifier affects them.

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

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

The description names a concrete resource ('damage done') and identifies the tool as a compatibility alias for get_damage_done, so the basic query target is inferable. However, the central qualifier 'bounded source semantics' is never defined, and the description relies on the reader knowing get_damage_done's contract rather than stating directly what the tool does. The title 'Get fight damage' helps, but the description alone is only moderately clear.

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 when-to-use or when-not-to-use guidance is given. The description does not say whether callers needing all damage done should use get_damage_done instead, nor what 'bounded source' means as a selection criterion. The reference to another tool implies comparison, but the decision rule is left entirely 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 readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds nothing concrete beyond the vague phrase "bounded WCL player/source semantics" – it does not explain what is bounded, how results are truncated, or what the return payload looks like, despite maxEntries/maxPayloadBytes parameters implying truncation 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?

It is a single short sentence with no filler, which is structurally clean. However, its brevity reflects under-specification rather than efficient communication of the essential facts an agent needs.

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 an 11-parameter tool with no output schema, the description is far too thin: it omits return-shape expectations, pagination/truncation behavior implied by maxEntries and maxPayloadBytes, and the alias relationship to get_damage_taken. Nothing beyond the name and annotations guides a correct invocation.

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

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

Schema coverage is only 64% across 11 parameters, so the description should compensate for the undocumented ones (e.g. abilityID, translate, maxPayloadBytes have no schema description). Instead it contributes a single unexplained phrase about "player/source semantics," adding essentially no meaning beyond what the schema already states.

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 only says it is a "Compatibility alias for get_damage_taken," which defines the tool by reference to a sibling rather than stating what it does (return damage taken by players/sources in a fight). "Bounded WCL player/source semantics" is jargon that does not resolve the ambiguity about whether this differs from get_damage_taken or merely duplicates it.

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?

Calling it a "compatibility alias" hints that it exists for backward compatibility, but there is no explicit guidance on when to pick this over the co-existing get_damage_taken sibling, nor any prerequisites or exclusions. The agent is left to guess which of the two near-identical tools to invoke.

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, openWorld, idempotent, and non-destructive behavior. The description adds meaningful context beyond this: it warns about full pagination, time-window, event-count, page-count, and byte protections. These are useful behavioral safeguards that an agent should know before calling. 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 a single sentence and wastes no words. It front-loads the most important fact (compatibility alias for get_events) and then summarizes the protective features. It is concise, though the list of protections is somewhat dense and could benefit from explicit parameter references.

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

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

This is a complex 17-parameter tool with no output schema and low schema coverage, so the description carries heavy responsibility. The one-sentence alias description is not enough for an agent to safely call the tool correctly. It omits parameter semantics, output behavior, and selection guidance, leaving too much 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?

With 17 parameters and only 41% schema description coverage, the description should compensate by explaining the meaning of key parameters. It vaguely references pagination, time-window, event-count, page-count, and byte protections, but does not map these to actual parameters like cursor, maxEvents, maxPages, startTime, or maxPayloadBytes. Most parameters remain unexplained.

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

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

The description clearly identifies the tool as a compatibility alias for get_events, so an agent understands it retrieves event data. The name 'get_fight_events' adds the fight context, and naming get_events distinguishes it from other siblings. However, it does not explicitly state 'retrieves fight events' in plain terms, relying on the alias and name.

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

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

The description offers no guidance on when to use this tool versus get_events or any other sibling. It calls itself a compatibility alias, which is a weak reason for selection, but does not explain scenarios, exclusions, or advantages over 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, openWorldHint, idempotentHint, and non-destructive, so the safety profile is fully covered. The description adds two behavioral facts — compatibility-shim status and bounded source scope — but 'bounded source semantics' is so vague that its concrete behavioral implication (which scope dimensions are restricted and how) is unclear.

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

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

At eight words, it is maximally compact and front-loads the most identifying phrase ('Compatibility alias for get_healing'). But the compactness sacrifices clarity: 'bounded source semantics' is dense jargon that an agent would likely need expanded.

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 an 11-parameter tool with no output schema, this description is thin. It provides no return-value information, no pagination/limit behavior, and no concrete definition of the bounded scope, leaving the agent to guess the tool's core semantics from its name alone.

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

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

Schema description coverage is only 64%, and the description adds zero parameter information. It does not clarify how fightID, playerID, and abilityID interact to define the 'bounded source' — the tool's central semantic — nor does it fill gaps left by the four undocumented parameters (abilityID, translate, maxEntries, maxPayloadBytes).

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 title 'Get fight healing' plus the alias reference to get_healing identifies a healing-query tool, and 'bounded source semantics' signals a scope restriction that distinguishes it from the sibling get_healing. However, the description never plainly states 'returns healing for a specific fight/source' — the clarity relies partly on inference from the name.

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 names get_healing as the aliased tool, giving one comparison point, but it never states when to choose this tool over get_healing or get_fight_damage. Worse, 'compatibility alias' could steer an agent toward preferring get_healing, implying this variant is deprecated. There is no explicit when/when-not 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, idempotentHint, and non-destructive behavior, so the safety profile is covered. The description adds modest context by noting the output is 'compact' and includes summary metrics and metadata, but it does not disclose additional behavioral details like output shape or localization behavior.

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

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

The description is a single, efficient sentence that front-loads the action and resource. Every phrase adds value, with no filler or redundant repetition 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?

The description conveys the tool's purpose and core output content, but it omits usage guidance and the meaning of the undocumented 'translate' parameter. With no output schema to compensate, an agent has only a partial picture for correct invocation in edge cases.

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

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

Schema description coverage is 80%, so most parameters are documented. The description does not clarify the undocumented 'translate' parameter or add parameter-specific detail; it mostly describes the output content rather than how parameters behave.

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 and resource: 'Get a compact raid or Mythic+ fight summary' with specific metrics like damage, healing, deaths, interrupts, and metadata. This distinguishes it from sibling single-metric tools, 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?

Usage context is only implied: the tool is for when a compact multi-metric summary is wanted rather than a specialized metric tool. It does not explicitly state when to choose this over get_report, get_mythic_plus_summary, or individual fight metric tools.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior, lowering the burden on the description. The description adds useful context that results are bounded and that playerID is interpreted as the WCL sourceID, but it does not explain truncation, defaults, or response behavior.

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

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

The description is extremely concise: two sentences, front-loaded with the main purpose, and no filler. Each sentence earns its place, though the overall definition could be more informative.

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 an 11-parameter tool with no output schema and many similar siblings, this description is too thin. It omits return shape, when to prefer this over get_fight_healing, and the practical effect of the bounding parameters, leaving an agent to guess important call behavior.

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

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

With schema description coverage at 64%, the description adds some meaning through 'bounded' (relating to maxEntries/maxPayloadBytes) and by clarifying playerID as the WCL sourceID. Still, several parameters such as abilityID and translate remain unexplained in both schema and description.

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

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

The description clearly states the tool returns healing evidence and highlights the key playerID-to-sourceID mapping, so an agent knows the basic resource. However, it does not distinguish this from the sibling get_fight_healing, leaving some ambiguity about scope.

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

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

The description gives no guidance on when to use this tool versus get_fight_healing, get_events, or other healing-related tools. The word 'bounded' faintly implies limited results, but there is no explicit context or alternative routing.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by saying results are 'bounded' and that 'playerID is correctly applied as WCL sourceID,' which clarifies an important filter behavior beyond what annotations provide. It does not contradict 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 short sentences with no filler. The core purpose is front-loaded, and the playerID clarification is concise and valuable. 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?

Given the tool has 11 parameters, no output schema, and moderate schema coverage, the description leaves meaningful gaps. It clarifies playerID and boundedness, but it does not explain what 'interrupt evidence' looks like, how abilityID filtering behaves, or what defaults apply. Annotations cover safety well, so this is not inadequate, but it is not fully complete either.

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 64%, so the schema already documents many parameters. The description adds meaningful clarification for playerID by specifying that it maps to WCL sourceID, and 'bounded' hints at the maxEntries/maxPayloadBytes behavior. However, it does not add semantic value for undocumented parameters like abilityID, translate, maxEntries, or maxPayloadBytes, so the added value is partial.

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

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

The description states a clear verb and resource: 'Get bounded interrupt evidence.' This is specific and distinguishes it from generic event tools, though it does not explicitly differentiate itself from siblings such as get_casts or get_events. The word 'bounded' adds useful scoping but is somewhat ambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives like get_events or get_casts. It does not mention exclusions, prerequisites, or the conditions under which an agent should prefer this tool. The only contextual hint is the mention of interrupts, which is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond that: the output is a compact overview and optional tables fail independently with warnings. This partial-failure behavior is valuable and not present in 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 compact and front-loaded: it states the purpose and content in one sentence, then adds a critical failure behavior in the second. Every sentence earns its place with no filler.

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

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

With no output schema, the description compensates by naming the main returned categories and warning about independent table failures. Combined with the annotations and schema, the agent has enough context to select and invoke the tool correctly, though a bit more detail on when the optional tables fail could improve completeness.

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

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

Schema description coverage is 80%, so the input schema already documents most parameters well. The description does not add parameter-level meaning beyond the schema, but it does help the agent understand what kind of report code/URL context is relevant (Mythic+). 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 a specific verb ('Get') and resource ('Mythic+ overview') and enumerates the contained fields: key, duration, dungeon, enemy forces, players, DPS/HPS, deaths, and interrupts. It does not explicitly differentiate from the sibling 'get_fight_summary', so it misses the top score.

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

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

The description implies the tool is for Mythic+ report summaries by naming that content type, but it does not say when to prefer this tool over alternatives such as get_fight_summary or list_dungeon_pulls. There is clear context but no explicit exclusions or alternative routing.

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

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

Annotations already establish read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral context beyond that by stating 'Components fail independently and return warnings,' which tells an agent that partial failures are expected and do not necessarily invalidate the entire response.

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

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

Two sentences deliver the core capability and the key failure behavior with no filler. The resource list is front-loaded and the behavioral caveat follows immediately.

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

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

The description gives a good high-level inventory of included data and warns about partial failures, which is useful without an output schema. However, it leaves gaps around output structure, parameter semantics, and when to prefer this aggregate over individual sibling tools.

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

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

The description contributes essentially no parameter-level guidance; only 'for one player' loosely maps to the player parameter. Since schema description coverage is only 50%, parameters like translate, maxEntries, maxPayloadBytes, and player remain largely undocumented by both the schema and the description.

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

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

The description states a specific action ('Aggregate') and a clear resource scope: bounded damage, casts, damage taken, interrupts, deaths, buffs, resources, CombatantInfo, and talent evidence for one player. This clearly separates it from the many individual sibling getters like get_casts or get_damage_done.

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 clearly frames this as a combined, one-player evidence context tool, which implies using it when multiple analysis components are needed rather than calling separate get_* tools. It does not list exclusions or explicitly name alternatives, but the aggregate scope provides clear context.

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

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

Annotations already establish that the operation is read-only and idempotent, so the description does not need to repeat that. It adds useful behavioral context by explaining that user-authorized access can include private reports, which goes beyond what the schema or annotations state.

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

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

The description is two sentences, front-loads the core action, and adds only one additional meaningful sentence about access behavior. There is no filler or repetition of schema 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 description covers the high-level purpose and return scope, and the annotations cover safety, but it is not fully complete for invocation. With seven parameters, zero required fields, and no output schema, the agent is left to infer how character identification works and whether active-character context can substitute for name/server/serverRegion.

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

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

Schema description coverage is only 29%, and the description does little to compensate. It mentions 'a character' and 'user access', which loosely map to name and accessMode, but it does not clarify semantics for server, serverRegion, contentType, page, or limit, nor does it explain how parameters interact.

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 a specific resource ('recent reports for a character'), and adds the scope of what is included ('report visibility and bounded fight metadata'). This clearly distinguishes it from siblings like list_fights or get_character_summary, which operate on different resources or perspectives.

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

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

The description implies when to use the tool: to get a character's recent reports, including private ones if authorized. However, it does not explicitly state when not to use it or point to alternatives such as get_report or list_fights, leaving some routing decision to the agent's 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 disclose readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is well covered. The description adds a small behavioral nuance with 'bounded' and lists the metadata fields returned, but it does not go beyond that. 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 front-loaded sentence that states the action and the specific data scope without any filler. Every word contributes to understanding the tool's purpose.

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

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

For a read-only metadata getter with robust annotations and detailed schema, the description is nearly complete. It lists the return fields, which is helpful since there is no output schema. The only minor gap is the ambiguous term 'bounded', which could confuse agents about what is excluded.

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 75% (three of four properties have descriptions), so the schema carries most parameter documentation. The description adds no parameter-specific details about report codes, regions, access modes, or allowUnlisted behavior. Baseline 3 is appropriate because the schema is already informative.

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 ('Get') and resource ('report metadata') and enumerates the exact data returned: visibility, zone, timestamps, and archive status. The word 'bounded' adds a scoping hint that distinguishes it from full report retrieval, though it is somewhat vague. It is clear overall but does not explicitly compare against sibling tools.

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

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

No explicit guidance is given on when to use this tool versus alternatives. The description implies use when metadata is needed, but it does not state exclusions, prerequisites, or mention sibling tools like get_recent_reports or parse_wcl_url. An agent must infer usage from the purpose 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 this is read-only, non-destructive, idempotent, and open-world, so the description's behavioral burden is lighter. It adds one useful behavioral detail—playerID is interpreted as a WCL sourceID—but it does not explain what 'bounded' means, how results are bounded, or what output shape to expect. 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 short and front-loaded, with no filler, so it earns credit for brevity. But the opening phrase 'bounded resource evidence' is jargon-heavy and under-specified, and the second sentence is an implementation detail that reads more like parameter documentation than a purpose or usage statement.

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 11 parameters, no output schema, and a large sibling tool set, the description is not complete enough to guide reliable selection. It does not describe what the returned evidence looks like, what bounds apply, or how this relates to the many nearby get_* tools. The annotations cover safety but not the semantic gaps.

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

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

At 64% schema coverage, the schema already documents most parameters, and the description adds a small clarification that playerID maps to WCL sourceID, slightly beyond the schema's 'source/target filter' wording. However, parameters like abilityID, translate, maxEntries, and maxPayloadBytes receive no description-side help, and the playerID note mostly duplicates the schema.

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

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

The description states a verb and object ('Get bounded resource evidence'), but never clarifies what 'bounded resource evidence' actually means or which resource types are included. It is less vague than a bare tautology, but it does not distinguish get_resources from the many sibling get_* tools beyond using the word '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?

There is no guidance about when to choose get_resources instead of get_events, get_casts, get_buffs, or get_character_casts. The only additional note, about playerID, is parameter clarification rather than usage direction. An agent would have to infer the intended use case from the tool name alone.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds context about Retail and WCL-recorded data, which is helpful, but it does not discuss auth nuances, error cases, or the effect of the translate parameter beyond what annotations and schema 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 sentence with no filler. The verb and object are front-loaded, and every phrase ('Retail', 'WCL recorded', 'one player in one fight') adds meaningful constraint.

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 adequately covers the core purpose, scope, and output type ('talent import string') for a read-only retrieval tool. With no output schema, it could ideally mention null/not-found behavior, but the simplicity of the tool and the clarifying parameter schema keep the overall context complete enough.

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%, so most parameters are already documented. The description adds a useful semantic link between 'one player in one fight' and actorID/fightID, but leaves translate and accessMode behavior entirely to the schema and 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 names a specific resource ('Retail talent import string'), source ('WCL recorded'), and precise scope ('one player in one fight'). This clearly distinguishes it from other get_* siblings like get_combatant_info or get_casts, which target entirely different data.

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

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

The unique, narrowly framed purpose implies when to use the tool: whenever an agent needs a WCL talent import string for a specific player and fight. However, it does not explicitly mention alternatives or state when not to use it, so the routing is left 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 cover readOnly, openWorld, idempotent, and destructive hints. The description adds useful context beyond annotations by clarifying that subscriptions are 'locally persisted' and that the result includes cursors, which is not encoded in the schema or 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 sentence with no filler. It front-loads the action and object while including only essential qualifiers: 'locally persisted' and 'cursors'.

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 list tool with rich annotations, the description is nearly complete. It states what is returned ('subscriptions and their cursors'), though it does not specify the exact return shape or empty-list behavior, which would be more important if an output schema were absent.

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

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

The input schema has zero parameters and 100% schema description coverage, so the baseline is 4. The description does not need to explain parameters because there are none.

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 names a concrete resource ('locally persisted character report subscriptions') plus the additional detail that cursors are included. It clearly conveys what the tool does, though it does not explicitly differentiate itself from the closely named sibling check_character_subscriptions.

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 choose this tool over check_character_subscriptions or the subscribe/unsubscribe siblings. The tool's read-only nature is implied by the verb, but no exclusions or alternatives are mentioned.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful context about the returned data (pull windows, locations, map IDs, NPC IDs) but does not discuss behaviors such as pagination, scoping to a fight/report, or authorization nuances.

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

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

A single, front-loaded sentence with no filler. Every word contributes to conveying the tool's purpose and distinguishing it from other list tools.

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 list operation with strong annotation coverage and a schema that documents all but one parameter, the description is nearly complete. It states what will be returned and in which domain. A minor gap is that it does not explicitly say the pulls are scoped to the report/fight identified by the required parameters, though this is inferable from the schema.

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

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

Schema description coverage is 80%, so the schema already documents the main parameters. The description does not add parameter-level detail beyond naming output fields like map IDs and enemy NPC IDs, which are not parameters. This matches the baseline for a well-covered 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 the specific verb 'List' and names the exact resource set: Mythic+ pull windows, locations, map IDs, and participating enemy NPC IDs. This clearly distinguishes the tool from any sibling that might also deal with fights or Mythic+ data.

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

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

No guidance is given about when to choose this tool versus alternatives such as list_fights or get_mythic_plus_summary. The intended use case is implied by the name and description, but there are no explicit conditions, exclusions, or alternative mentions.

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 read-only, idempotent, and non-destructive, so the description only needs to add behavioral context. It adds the selectedFightID statement, which conveys response behavior, but it is cryptic and does not explain the shape of the returned fight list or the significance of a missing selector.

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 brief and front-loaded, with the core purpose in the first sentence. The second sentence is compact but slightly obscures meaning by using selectedFightID without defining it in the schema.

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 list operation with strong annotations and good schema coverage, the description is minimally viable. Missing pieces include what raid and Mythic+ metadata the response contains and how the fight selector interacts with the fightID parameter; with no output schema, a bit more return-shape context would make it 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 high (80%), so the schema carries most parameter semantics; the description need not repeat them. However, the description adds no parameter-level clarification and introduces selectedFightID without tying it to any schema property, leaving a small semantic 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 uses a specific verb ('List') and a clear resource ('fights with raid and Mythic+ metadata'), which makes the tool's purpose immediately understandable. It does not explicitly name a sibling or contrast itself with get_fight_summary and related get_fight_* tools, so differentiation is left to the name and context.

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

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

The description gives no guidance about when to choose list_fights over the many fight-related siblings such as get_fight_summary or get_fight_damage. The 'if a fight selector is present' clause touches output semantics rather than use cases, so an agent has to infer selection criteria.

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

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

Annotations already convey read-only, open-world, idempotent, and non-destructive behavior. The description adds value by explaining what data is associated with players and that fight selection narrows results, which is meaningful 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?

Two concise sentences with no redundant phrasing. The core purpose is front-loaded and the optional fight-selection behavior is stated 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?

For a read-only list operation, the description sufficiently conveys what data will be returned and how fight selection affects scope. Since there is no output schema, the description gives enough context without needing exhaustive return formatting details.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description only loosely relates to fightID via the fight selector mention and does not add further parameter-level detail, keeping this at baseline.

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

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

The description clearly states the tool lists player actor IDs and maps their observed specs and item levels to fights. This is specific and distinguishes it from sibling tools like list_fights or get_combatant_info.

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

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

The description implies the tool is used to obtain player information for a report, and mentions a fight selector narrows participants. However, it does not explicitly state when to prefer this over alternatives or provide exclusion conditions.

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 tool read-only, idempotent, and non-destructive. The description adds meaningful behavioral specifics beyond those annotations: it validates allowed hosts, includes query/hash selectors, and rejects look-alike or unsafe URL forms. It does not describe exact error behavior, but the annotation coverage keeps this acceptable.

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

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

One dense sentence delivers the action, accepted hosts, selector handling, and rejection behavior with no filler. Key constraints are front-loaded and nothing is repeated from 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?

The description fully identifies the operation and validates the input scope, but because there is no output schema it omits the return structure of a parsed URL and the exact rejection/error behavior. For a one-parameter utility with rich annotations this is acceptable, yet an agent would still need to infer downstream usage.

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

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

With 0% schema description coverage and a single url parameter, the description compensates by defining what counts as a valid input: a Warcraft Logs report URL on specific hosts, including query/hash fight selectors. It does not explicitly state output structure, but the single parameter's scope is well clarified.

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 (parse), a specific resource (Warcraft Logs report URLs on www.warcraftlogs.com or cn.warcraftlogs.com), and the key distinction from sibling data-retrieval tools: it handles query/hash fight selectors and rejects unsafe forms. This makes its role clear and distinct.

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 when converting or validating Warcraft Logs report URLs, especially with fight selectors, but it never explicitly states when to use this tool before others or when not to use it. No alternatives are named, so an agent must infer the workflow.

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 that this is a mutating (readOnlyHint=false), non-destructive operation. The description adds the behavioral details that input is validated before the value is persisted, but it does not disclose failure behavior or whether a previously set active character is overwritten.

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

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

The description is a single, focused sentence with no filler. The core action, resource, and purpose are front-loaded, making it easy to parse quickly.

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

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

For a simple three-parameter setter with no output schema, the description and input schema provide enough information to call the tool successfully. It lacks explicit return or error-handling details, but the basic intent and persistence behavior are clear.

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

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

Schema description coverage is only 33%: only 'server' has a description, while 'name' and 'serverRegion' rely on type and enum. The description does not meaningfully explain these parameters beyond labeling the resource as a character, so it does not compensate for the low schema coverage.

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

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

The description uses a specific verb phrase, 'Validate and persist,' and clearly identifies the resource as the default character. It also states the scope of use ('character discovery and ranking tools'), which distinguishes it from sibling tools like get_active_character and clear_active_character.

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

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

The description implies the tool is used before character discovery or ranking operations by saying the character is 'used by character discovery and ranking tools,' but it does not explicitly state when to call it or contrast it with alternatives such as get_active_character or clear_active_character.

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 indicate a non-read-only, non-idempotent, non-destructive operation. The description adds meaningful context beyond that: subscriptions are persistent, pull-based, and use current reports as a baseline so later checks only return new reports. This clarifies state-changing behavior 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?

The description is two concise sentences with no filler. The primary purpose is front-loaded, and the baseline behavior follows naturally. Every word earns its place.

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

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

Given the annotations and schema, the description covers the core persistent-subscription behavior and the polling model well. It omits explicit routing to the check/unsubscribe siblings and repeated-subscription behavior, but those gaps are partially filled by sibling names and the idempotentHint. It is reasonably complete for correct selection and invocation.

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

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

Schema description coverage is only 20%, so the description needed to compensate. It adds useful semantics for the includeExisting default by explaining that current reports become the baseline, but it does not name includeExisting or clarify the true case. Other parameters like name, server, serverRegion, and accessMode rely on the schema or self-evident naming.

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

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

The description states a specific action and resource: 'Persist a pull-based subscription.' It also adds the key baseline behavior that distinguishes this tool from siblings like check_character_subscriptions and unsubscribe_character. The title reinforces the resource ('character reports').

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 a pull/poll workflow by saying 'later checks return only newly discovered reports,' but it never names or contrasts the sibling tools for checking, listing, or unsubscribing. There is no explicit when-to-use or when-not-to-use guidance, so usage is mostly inferred.

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 provide destructiveHint=true and readOnlyHint=false, so the description's 'Delete' aligns with them. The added 'locally persisted' context is valuable, but the description does not go deeper into effects like irreversibility, cascading deletions, or what happens if the subscription ID does not exist. It earns a pass but not more.

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

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

The description is a single focused sentence with no filler. It starts with the action verb and clearly states the object and scope, making it easy to parse quickly.

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

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

This is a simple one-parameter destructive tool with annotations covering mutation and no output schema. The description states that the subscription is locally persisted, which is relevant operational context. It could mention expected return or failure behavior, but for a straightforward delete operation it is sufficiently 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 carries the burden of explaining parameters. It does not explain subscriptionID at all beyond what the property name and schema format already show. The single parameter is fairly self-evident, but the description adds no semantic value for it.

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

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

The description states a specific verb and object: 'Delete one locally persisted character report subscription.' This clearly identifies the action and resource, and differentiates it from sibling tools like subscribe_character and list_character_subscriptions. The 'locally persisted' qualifier adds useful scope.

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

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

The description implies its usage: call it to delete a single saved subscription. However, it does not explicitly state when to use it versus alternatives, such as checking existing subscriptions first or creating new ones with subscribe_character. The guidance is only implicit, not explicit.

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