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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is partly covered. The description adds useful behavioral context beyond them: it returns cleanly with inChampSelect: false when no draft is active, so the agent knows a null-ish result is normal rather than an error. It stops short of describing rate limits or latency, keeping it at 4.

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?

Front-loads the core capability, then routes to siblings, then states behavior and returns. Every sentence earns its place with no filler or repetition.

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

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

With no parameters, no output schema, and coverage of the safety profile already in annotations, the description supplies the remaining essentials: the analysis performed, the inactive-draft edge case, and the shape of the return (draft breakdown plus composition warnings). Nothing needed to call it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description appropriately focuses on behavior and output rather than inventing parameter guidance.

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

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

States a specific verb (scouts) and resource (active allied team draft in champion select) plus the concrete analysis it performs: physical vs magic damage distribution and composition gaps. An agent can distinguish it from sibling workflow tools without opening the schema.

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

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

Explicitly scopes usage to the champion select draft phase and names the alternatives for adjacent actions: lol_workflow_champ_select for locking/hovering/banning and lol_workflow_runes_set / lol_workflow_spells_set for runes and spells. When-to-use and when-not-to-use are both covered.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, but the description adds real behavioral context beyond them: the data source (local Live Game Engine on port 2999), the absence of external network calls, and the edge-case return of inGame: false when no match is running. It stops short of rate limits or failure modes, but the added source and no-match semantics are genuinely useful.

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?

Four tight sentences, front-loaded with what is extracted, then usage, then alternatives, then behavior. Every sentence carries distinct information with no filler, though the routing and behavior clauses could be trimmed slightly.

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 tool with no output schema, the description covers source, usage, alternatives, safety, and the no-match edge case. It could go further in sketching the returned shape, but it is complete enough to call correctly and interpret the inGame: false case.

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

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

The tool takes zero parameters, so there is no parameter semantics to document and the baseline is 4. The description correctly avoids inventing parameters and instead describes the data categories the call returns.

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

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

The description opens with a specific verb ('Extracts') and enumerates the exact resource: real-time combat status, lane gold/level comparisons, match clock, and team score differentials. It names the source ('Live Game Engine on port 2999') and distinguishes itself from siblings lol_game_all, lol_game_player, and lol_analytics_match_detail, so an agent can select it without opening another schema.

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

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

It states the usage context explicitly ('during active live games to assess map state, score leads, or lane advantages') and routes to named alternatives with the conditions that select them: raw data/item builds go to lol_game_all or lol_game_player, post-game analysis goes to lol_analytics_match_detail. Both when-to-use and when-not-to-use are covered.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and idempotentHint=true, so the safety profile is covered; the description partly repeats this ('Safe and read-only ... without modifying items') but adds the local-inventory scope and, with no output schema, tells the agent it returns essence summaries and shard lists. Useful, though the safety restatement is redundant against 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?

Front-loaded with the purpose, then usage, alternatives, behavior, and returns in labelled sentences. Mostly tight, but the 'Safe and read-only ... without modifying items' clause spends words re-stating annotation hints, which slightly dilutes it.

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 input parameters and no output schema, the description must carry the return story itself, and it does ('Returns essence summaries and shard lists'), while also covering purpose, routing alternatives, and behavioral posture. Nothing an agent needs to invoke it is missing.

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

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

Zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly says nothing about inputs, matching the empty 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?

States a specific verb and resource with scope: 'Calculates total potential Blue Essence (from champion shards) and Orange Essence (from skin shards) along with shard breakdown in player inventory.' It names the disenchant and generic-request siblings as distinct tools, so an agent can separate it from adjacent loot tools without opening a schema.

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

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

Explicit when-to-use ('evaluating available crafting materials, essence totals, or preparing to disenchant duplicate shards') and names two alternatives with their selecting conditions: lol_workflow_loot_disenchant for executing recipes and lol_request for store/catalog purchases.

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 the safe read-only, idempotent profile, so the description's marginal contribution is the auto-default to the most recent match when gameId is omitted and the shape of the return ('structured objective and player breakdowns'). That is genuinely useful context beyond the annotations, though it stops short of noting cost/latency or data-availability edge cases (e.g., what happens with an invalid gameId).

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?

Front-loaded with the payload of computed metrics, then routing, then behavior – a sensible order. The closing 'Returns structured objective and player breakdowns' slightly restates the opening enumeration, which keeps it from a perfect score, but the text is otherwise dense and waste-free.

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 single-optional-param analytics tool with no output schema, the description covers what is computed, when to reach for it, the sibling alternatives, the default behavior, and the general return shape. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% for the single gameId parameter, and the schema itself already documents the most-recent-match fallback, so the description's restatement adds nothing new. Baseline 3 is appropriate when the schema carries the parameter burden.

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

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

States a specific verb ('Calculates advanced post-game metrics') with a concrete enumerated resource (damage share %, gold efficiency, KP %, vision score, objective counts). An agent can distinguish it from lol_analytics_match_history and lol_analytics_live_combat purely from the opening sentence.

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

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

Explicitly gives the when-to-use case ('analyzing the decisive factors, individual carrying performance, or throws of a specific completed match') and names both alternatives with the condition that selects them (match_history for brief multi-match views, live_combat for in-progress matches). This is textbook routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description still adds value by disclosing the data sources ('local client match history and static champion data') and the return shape ('array of concise match objects'), though it omits pagination or freshness details.

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

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

Four sentences, all front-loaded with the core purpose first, then alternatives, then behavior. Slightly longer than strictly necessary but every sentence carries routing or behavioral information.

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

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

With no output schema, the description compensates by naming the returned fields (champion names, KDA, win/loss, duration, queue IDs) and the container type, and it covers sourcing and read-only behavior — enough for an agent to call it correctly.

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

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

Schema description coverage is 100%, so limit, puuid, and queueId are already fully documented with defaults and examples. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('Retrieves a token-efficient, compact list of recent match history games for a summoner') and enumerates the returned fields, letting an agent distinguish it from siblings without opening schemas.

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

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

Explicitly names the when ('need an overview of recent games without filling the context window') and routes to alternatives by condition: lol_analytics_player for ranked stats/winrates, lol_analytics_match_detail for single-game deep dives.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds useful context by stating that it queries local client cache and REST endpoints and returns structured performance metrics, though it does not detail pagination or response shape.

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 front-loaded with the tool's purpose, followed immediately by usage guidance and alternative routing. Every sentence contributes either purpose, routing, or behavioral context, with no wasted prose.

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?

Although no output schema exists, the description lists the concrete metrics returned and gives sufficient usage and behavioral context. With annotations covering safety and schema covering parameters, an agent has everything needed to select and invoke it correctly.

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

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

Schema description coverage is 100%, so both parameters (puuid and matchCount) are fully documented in the input schema. The description adds no parameter-specific syntax, defaults, or constraints beyond what the schema already provides, making baseline 3 appropriate.

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

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

State a specific verb (Evaluates) and resource (summoner profile analytics) and names the exact metrics returned: ranked tiers, LP, winrate, average KDA, CS per minute, and primary champion pool. It distinguishes itself from lol_analytics_match_history and lol_analytics_match_detail explicitly.

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

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

Provides explicit use cases (assessing skill level, ranked progression, preferred champions before or after matches) and names two alternatives with the conditions that select them. An agent can route correctly without opening sibling schemas.

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 meaningful behavior beyond the annotations: logs are buffered in memory, capture survives renderer page reloads with continuity, and an active CDP connection is required. It also clarifies that stopping releases memory, which aligns with the non-destructive annotation. The annotations already cover safety and idempotency, so this is strong supplemental context.

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

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

The description is front-loaded with the core action and then layers usage, alternatives, behavior, and prerequisite in clearly separated sentences. Every sentence adds useful decision-making information without repetition. The length is appropriate for a tool with several sibling alternatives.

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

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

There is no output schema, but the description explains what is captured, where it goes, how to retrieve it, and how to stop it. It also covers the prerequisite and reload-survival behavior, which are important for correct invocation. Nothing essential is missing for an agent to call this tool correctly.

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

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

The tool takes no input parameters, so there are no parameter semantics to document. This matches the baseline score of 4 for a zero-parameter tool, with no schema gap to 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 states a specific verb and resource: attach to the League Client renderer via CDP and start streaming console logs, warnings, and uncaught exceptions. It distinguishes itself from siblings by naming retrieval, stopping, and disk-log alternatives. An agent can identify this as the console-capture start tool without ambiguity.

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

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

It says exactly when to use the tool: before executing UI actions or testing plugins to capture frontend diagnostics. It also routes to alternatives for retrieving data (lol_cdp_console_tail), stopping capture (lol_cdp_console_stop), and reading disk logs (lol_logs_tail). This provides explicit when-to-use and when-not-to-use guidance.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, but the description adds the critical consequence that remaining unread entries in the in-memory buffer are discarded. It also explains that stopping releases memory and closes the CDP socket, which is meaningful behavioral context beyond the annotations.

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

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

The description is four compact sentences, front-loaded with purpose, then usage, alternative, and behavioral consequence. Every sentence adds actionable information without repetition.

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

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

With no output schema, zero parameters, and rich annotations, the description supplies what an agent needs: when to call it, what gets discarded, and the sibling alternative. Nothing essential for correct invocation is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description does not need to document any inputs, and there is no schema coverage gap to 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 states a specific verb and resource: detach from the League Client renderer and terminate the console log buffering session. It explicitly distinguishes itself from the sibling lol_cdp_network_stop, so an agent can tell what this tool does without opening the schema.

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

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

It gives explicit timing for use: when console log capture is complete, to release memory and close the CDP socket. It also names the correct alternative for stopping network request capture, lol_cdp_network_stop instead.

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, closed-world. Beyond that, the description discloses the failure mode (errors when tailer isn't running), the prerequisite chain, and gap-free cursor polling semantics - behavioral context 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?

Front-loaded purpose followed by use cases, prerequisite, alternative, and cursor behavior - each sentence earns its place with no filler. Slightly dense but well ordered.

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

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

For a 7-param read tool with no output schema, the description covers what is returned (logs, warnings, exceptions), the prerequisite, and incremental polling semantics. Return-shape specifics (fields per entry) remain implicit, but annotations carry the safety profile.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters including cursor. The description only adds the conceptual framing of cursors as sequential gap-free markers, without syntax or format detail beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb and resource (retrieve buffered console logs, warnings, JS exceptions) with scope boundaries (since tailer started or past a cursor). It explicitly carves out the sibling lol_cdp_network_tail for HTTP traffic, so an agent can distinguish them without opening schemas.

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

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

Names concrete use cases (inspect frontend errors, check mounting logs, debug UI scripts), states a hard prerequisite (must call lol_cdp_console_start first; fails if tailer not running), and routes HTTP traffic to an alternative tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds meaningful context beyond that: the CDP-via-Pengu-Loader prerequisite and the fallback to lol_status on connection failure, which an agent needs before invoking. No return-shape or cost details, so not a 5.

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?

Front-loads what is inspected, then what is identified, then usage and prerequisite, with no filler sentences. Dense but every clause maps to a real behavior; slightly long selector list is the only mild drag.

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 must carry the return content, and it does by enumerating what gets reported (dialogs, blocking overlays, active plugins, focused element). Prerequisite and failure handling are covered; it stops short of describing the shape of the DOM tree output or size limits.

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

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

Schema description coverage is 100%, so both maxDepth and includeOverlaysOnly are fully documented in the schema; the baseline is 3. The description hints at the overlays-only mode ('returns only active modals, invisible backdrops and viewport info') but does not add depth or format semantics beyond what the schema 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?

States a specific verb (inspects) and resource (CEF DOM hierarchy, modal stack, overlays, viewport route), and enumerates the exact signals it looks for (.modal-container, lol-uikit-dialog-frame, transparent overlays, rcp-fe-lol-* plugins, focused element). An agent can distinguish it from lol_dom_query or lol_eval from the description alone.

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 clear trigger conditions ('diagnose unclickable UI buttons, stuck modals, or verify client screen state') plus a prerequisite and a recovery path ('check lol_status if connection fails'). It does not name an explicit alternative such as lol_dom_query, so it falls short of a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds genuine context beyond them: it reaches the live renderer cache, requires the request to have been captured in the current session, and fails if the entry was evicted or the client reloaded. It does not mention payload size limits or binary/truncation handling, which matter for a body-fetching tool.

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

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

Four compact sentences, front-loaded with purpose and routing guidance before the behavioral caveats. Structurally clean with no filler, though the 'Behavior:'/'Prerequisite:' labels add slight verbosity.

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

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

With no output schema and only one parameter, the description briefly characterizes the return as a raw response body payload and covers session-lifetime constraints. It stops short of describing what an agent gets for large/binary bodies or whether the payload is truncated, which is the main remaining gap.

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

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

Schema description coverage is 100% and the single requestId parameter is already documented as 'Unique request identifier returned in a lol_cdp_network_tail entry.' The description restates this indirectly but adds no syntax, format, or lookup guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource: fetch the raw response body for a specific captured request ID from the live renderer. It explicitly contrasts with the sibling lol_cdp_network_tail, so an agent can distinguish the two without opening either schema.

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

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

Gives explicit sequencing advice ('use this tool after lol_cdp_network_tail') plus a clear when-not condition ('for high-level request metadata or status codes without bodies, lol_cdp_network_tail suffices'). The alternative and the condition that selects it are both named.

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 safety is covered. The description adds meaningful behavior beyond that: the prerequisite that recording must be active, the computed statistics, and the initiator-trace extraction. It doesn't describe the response shape or how endpoints are normalized, but adds real context over 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?

Front-loaded with the core purpose, then outputs, then use cases, then prerequisite. Every sentence carries information, though the dense enumeration of computed statistics is on the longer side for a three-parameter tool.

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 usefully enumerates what the tool produces (percentile latencies, slowest requests, error groups) and states the prerequisite. It is nearly complete for calling correctly; only the exact return structure and endpoint-normalization rules are left unspecified.

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

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

Schema description coverage is 100%, with all three parameters (limit, thresholdMs, includeInitiators) fully documented in the schema. The description only loosely gestures at the threshold concept via 'exceeding a threshold duration', adding little beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (analyzes) and resource (captured HTTP network requests) and enumerates concrete outputs: P50/P90/P99 latencies per normalized endpoint, slowest requests with initiator stacks, and grouped 4xx/5xx/transport errors. This differentiates it from the plain sibling lol_cdp_network_summary without needing to open either schema.

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

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

Gives clear usage scenarios (diagnose frontend lag, sluggish LCU REST endpoints, broken plugin scripts, missing icons) and an explicit prerequisite: network recording must be active, call lol_cdp_network_start first. It stops short of naming a specific alternative or stating when-not-to-use it, so it's clear context without exclusions.

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

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

Annotations cover safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the bar is lower, and the description still adds useful context: what is captured (metadata, headers, status codes, timing) and the prerequisite of an active CDP connection. It doesn't say what happens to a previously captured buffer on re-invocation, which is the main remaining gap.

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

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

Front-loads the core action, then layers usage, routing, behavior, and prerequisite in clearly ordered sentences. It is on the longer side and the 'Behavior'/'Prerequisite' labels are slightly verbose, but no sentence is wasted given the routing value it provides.

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, no-output-schema tool with annotations present, the description covers purpose, capture scope, prerequisite, and follow-up tools. The one omission is how recording terminates (lol_cdp_network_stop exists as a sibling but is not referenced), leaving the lifecycle slightly incomplete.

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

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

Zero parameters and empty input schema, so per the rubric the baseline is 4. There is no parameter surface for the description to clarify or obscure.

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 (attach via CDP and begin capturing outgoing/incoming HTTP/HTTPS requests) plus the storage destination (in-memory buffer). It is clearly distinguishable from siblings like lol_cdp_network_tail, summary, or body, which are named as downstream consumers rather than competitors.

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

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

Explicitly says when to use it (monitor REST traffic, measure endpoint latency, debug failed API calls) and routes to alternatives for other needs: tail/summary for inspection, body for payloads, lol_events_*/lol_wamp_record_* for WebSocket events. This is explicit when-to-use plus when-not-to-use coverage.

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?

Adds behavior beyond the annotations by naming what is lost ('Discards in-memory network buffers') and confirming safety when already stopped. The idempotency claim duplicates idempotentHint and destructiveHint already signals mutation, but the buffer-discard detail is genuinely useful context.

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

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

Three tight sentences with the action front-loaded, followed by when-to-use and behavior. No filler or repetition.

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

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

With no parameters, no output schema and annotations covering the safety profile, the description gives the agent enough to call it correctly. The one missing piece is a warning that captured data must be retrieved (via tail/body/export) before calling this, since buffers are discarded.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond what the empty schema shows. Baseline 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?

States a specific verb and resource: 'terminate the network traffic recording session' and 'Detach from the League Client renderer'. This is clearly distinguishable from the sibling start/tail/body tools in the cdp_network family.

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

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

Explicitly gates use on completion: 'Use this tool when network analysis is complete to release memory and close the CDP monitoring session.' No exclusions or sibling alternatives are named, so it stops short of a 5 — notably it never tells the agent to export or tail captured data before stopping, even though the buffers are discarded.

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 non-obvious value beyond them: it summarizes an in-memory buffer and does not consume or alter stream cursors, which matters given the sibling stream/polling tools. It stops short of describing buffer limits or how long data is retained.

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 sentences, front-loaded with purpose, then usage/routing, then behavior. Every sentence carries distinct load and none repeats the structured fields verbatim.

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 enumerating what the summary returns (status breakdown, total byte volume, median duration). Combined with the read-only/non-consuming behavior note and explicit sibling routing, an agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents since/until/method/urlContains in detail. The description mentions the filtering concepts in prose but adds no syntax, format, or default behavior beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Aggregate and summarize captured HTTP requests') plus the exact aggregation dimensions (method, endpoint URL pattern, status breakdown, bytes, median duration). It also distinguishes itself from lol_cdp_network_tail by scope, so an agent can separate the two without opening schemas.

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

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

Explicitly names the use cases (high-volume polling traffic, top endpoints, systemic failure rates) and names the alternative tool (lol_cdp_network_tail) with the condition that selects it (individual request inspection with timestamps). Nothing 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 the safe-read profile, but the description adds real behavioral context: the precondition that recording must be running, and that returns include both completed and active in-flight requests. This goes beyond what the annotations provide.

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

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

Front-loaded with the core action, then purpose, prerequisite, and alternatives in a logical order. Every sentence earns its place with no redundancy.

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

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

With no output schema, the description responsibly states what is returned (completed plus in-flight requests), covers the prerequisite that gates successful invocation, and routes to sibling tools for bodies and aggregate stats.

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

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

Schema coverage is 100%, so all 11 parameters are already documented, including filters like status, urlContains, minStatus, and cursor. The description only restates the filter dimensions (status, URL pattern, method) without adding syntax or semantics beyond the schema, which is the expected 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?

States a specific verb (Retrieve) and resource (captured HTTP network requests from the in-memory buffer) with the filtering scope. It distinguishes itself from siblings by naming lol_cdp_network_body for bodies and lol_cdp_network_summary for stats.

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?

Explicit when-to-use ('inspect recent client network calls and identify 4xx/5xx errors or hung requests'), a hard prerequisite (must call lol_cdp_network_start first, fails otherwise), and two named alternatives for adjacent needs.

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, open-world, so safety is covered. The description adds meaningful context beyond that: the privacy/requirements caveat that CDP tools need Pengu Loader while standard LCU REST/events/workflows do not, plus the diagnostic/non-mutating nature of the call.

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?

Four sentences, front-loaded with purpose then metrics then use cases then prerequisite. Every sentence carries information, though the parenthetical Pengu Loader note is somewhat parenthetical weight that could be trimmed.

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 parameters and no output schema, the description carries the return-value burden and does so by enumerating the gathered metrics and warning flags. It also covers prerequisites and troubleshooting, leaving little an agent needs before calling it; only the exact output shape is unstated, which is acceptable here.

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

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

The tool takes zero parameters, so the baseline is 4. The description appropriately adds no parameter guidance because none exist, and it front-loads what the (parameterless) call returns instead.

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

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

States a specific verb and resource (inspect CEF performance/memory metrics for the League client frontend) and enumerates the exact metrics returned (JS heap size, DOM node count, layout/recalc counts, task/script duration, memory pressure flags). It is clearly distinguishable from siblings like lol_cdp_network_summary or lol_cdp_dom_tree.

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 concrete use cases (detect memory leaks, detached DOM nodes, renderer lag in frontend plugins) and a prerequisite plus failure fallback (CDP via Pengu Loader; check lol_status if connection fails). It does not explicitly name a preferred sibling alternative when CDP is unavailable beyond the status check, so it falls just short of a 5.

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

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

Annotations declare readOnlyHint=false, destructiveHint=true and idempotentHint=false; the description discloses that filesystem side effects occur only when savePath is supplied, which aligns with that profile, plus the remote-debugging prerequisite. However, calling the operation a 'Safe read' sits in mild tension with readOnlyHint=false/destructiveHint=true and the description never states that screenshots are non-idempotent or that client state is unaffected.

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?

Front-loaded with the core action, then cleanly sectioned into When to use / When NOT to use / Behavior / Prerequisite / Returns. The 'Required for CDP tools only' parenthetical is slightly awkwardly placed and lengthens the prerequisite sentence without adding much.

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 describing the dual-payload return (base64 image block plus JSON metadata with format, dimensions, byte length, savedTo). Prerequisites, alternatives and write conditions are all covered; only the read-only vs destructive framing is left slightly ambiguous.

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

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

Schema description coverage is 100%, so format, quality, savePath and targetId are already fully documented in the schema. The description restates savePath's write condition and points to lol_cdp_targets for targetId selection, which is useful routing, but adds no syntax or format detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('Capture a visual screenshot image of the active League Client window or a specific renderer target') and explicitly distinguishes itself from the two nearest siblings by naming them (lol_dom_query, lol_get). An agent can select this tool without opening any schema.

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

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

Gives an explicit 'When to use' (visual rendering / modal layout / graphic verification) and a 'When NOT to use' that routes to the correct alternatives (lol_dom_query for state checks, lol_get for API data). Prerequisite conditions and the lol_status fallback are also named.

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 it read-only, idempotent, and non-destructive, and the description adds substantial behavior beyond them: automatic redaction of auth tokens/passwords/sensitive cookies, JSON auto-parsing, and the CDP-via-Pengu-Loader prerequisite. These are exactly the operational and sensitivity details an agent needs before invoking.

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?

Four sentences, front-loaded with what it inspects, then behavior, then the prerequisite. Each sentence carries information; density is high but nothing is redundant 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?

No output schema exists, so return shape is not documented; the description covers sensitive-data redaction and prerequisites well but does not describe the response structure for local/session storage results. Given the read-only annotations and complete param coverage, remaining gaps are minor.

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

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

Schema coverage is 100%, so the baseline is 3, but the description restates the filtering (case-insensitive substring across keys and values) and JSON parsing semantics coherently in prose, aiding invocation. It does not add syntax or format detail beyond the schema, and storageType is only implied by the title.

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

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

States a specific verb (Inspects) and resource (CEF localStorage/sessionStorage entries) and elaborates the concrete content types it extracts (settings, feature flags, cached configs, themes). An agent can distinguish it from generic data tools like lol_get or lol_eval because the resource and scope are explicit.

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

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

Provides a clear prerequisite (CDP must be enabled via Pengu Loader) and names a concrete fallback action (check lol_status if the connection fails), which is real when-to-use guidance. It does not, however, contrast the tool against close siblings like lol_dom_query or lol_eval, so it stops short of explicit alternative selection.

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

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

Annotations already declare readOnlyHint/idempotentHint/destructiveHint, so the 'Safe and read-only' line is largely redundant. The real added value is the prerequisite disclosure: the League client must be running with remote debugging enabled via Pengu Loader, plus the note that other LCU REST/event/workflow tools work without it.

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?

Front-loaded with purpose, then usage, then behavior and prerequisite. Every sentence carries information, though 'Safe and read-only' duplicates annotation data and could be trimmed.

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 conveys what is returned (the list of targets and their IDs) and the gating prerequisite. No parameter docs are needed. Minor gaps remain around pagination/format of the target list, but nothing blocks 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. The description correctly presents this as a no-argument discovery tool.

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

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

States a specific verb+resource ('Discover and list all active CDP debugging targets') and enumerates the target kinds (pages, modals, worker contexts) exposed by the League Client. It also differentiates from siblings by naming the downstream tools (lol_cdp_screenshot, console/network tailing) it feeds.

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

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

Explicitly says when to use it: to inspect renderer contexts and discover target IDs before targeted screenshots or console/network tailing. It does not state when not to use it (e.g., for untargeted CDP operations), but the downstream routing is clear.

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

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

Annotations already declare the write/destructive/open-world profile, so the bar is lower. The description adds genuinely useful context beyond them: auto-resolution of the active team/lobby chat when conversationId is omitted, and the required write-allowlist endpoint ('POST /lol-chat/v1/conversations/*/messages'). It does not address the destructiveHint flag (e.g., that the message is public and cannot be recalled), leaving one gap.

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

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

Front-loaded with the core action, followed by usage, alternative, behavior, and auth in a logical order. Slightly redundant: 'Sends a text chat message...' and the later 'Behavior: Sends a chat message to client conversations' repeat the same premise, costing a bit of tightness.

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 two-parameter action tool with no output schema, the description covers everything needed: what it does, when to use it, the sibling alternative, default-resolution behavior, and the authorization requirement. An agent has sufficient information to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both message and conversationId thoroughly. The description's note that conversationId omission auto-resolves the active chat largely restates the schema's own wording; it adds no further format, length, or edge-case detail. Baseline 3 applies.

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

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

States a specific verb (sends) and resource (text chat message) plus the exact scope it targets: champion select, lobby, custom game conversation, or a specific conversation ID. It explicitly distinguishes itself from the sibling lol_chat_status, so an agent can route correctly without opening either schema.

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

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

Explicitly says when to use it (communicating team plans, role preferences, or greetings during lobby or draft phases) and names the alternative (lol_chat_status) with the condition that selects it (availability/custom status updates). Both the positive trigger and the exclusion are present.

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 non-read-only, idempotent, destructive, open-world. The description adds genuinely new behavioral context: it mutates friend presence state, is idempotent when re-setting the same status, and requires 'PUT /lol-chat/v1/me' on the write allowlist. It stops short of explaining what is destroyed or whether a missing allowlist entry causes an error.

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?

Purpose and usage are front-loaded in the first two sentences, with the behavioral/allowlist note kept terse at the end. The enum repeat ('chat', 'away', 'dnd', 'mobile') is mildly redundant with the schema but the rest earns its place.

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

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

For a two-parameter tool with no output schema and full schema coverage, the description covers purpose, usage, sibling routing, and the write-allowlist prerequisite — nothing an agent needs in order to call it correctly is missing.

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

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

Schema description coverage is 100%, so both parameters are fully documented in the schema. The description echoes the availability enum and the status-message concept but adds no syntax, defaults, or edge-case semantics beyond that, matching the baseline of 3.

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

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

States a specific verb (updates) and resource (local player's chat availability and status message), and enumerates the accepted availability values, so the agent knows exactly what the tool acts on.

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

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

Explicitly says when to use it (setting do-not-disturb, stepping away, broadcasting a custom status) and names the alternative for a different need: 'For sending chat messages to conversations, use lol_chat_send instead.'

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, destructiveHint=false, and openWorldHint. The description adds meaningful behavioral context beyond annotations: the CDP/Pengu Loader dependency, the troubleshooting step (check lol_status if connection fails), and the note that other tool categories work without Pengu Loader. It does not detail return format or rate limits, but the setup and safety context are valuable.

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 front-loaded with purpose and usage guidance, then alternatives and prerequisites. It is slightly long due to the final note about Pengu Loader and non-CDP tools, which is ecosystem context that is helpful but not strictly about invoking this tool. Overall, most sentences earn their place.

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

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

For a CDP-based query tool with rich annotations and full schema coverage, the description is complete: it covers purpose, routing to alternatives, prerequisites, failure recovery, and the broader Pengu Loader requirement. No output schema exists, and return details are not essential for 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 description coverage is 100%, so all three parameters (selector, all, props) are fully documented in the schema. The description adds no parameter-specific meaning beyond what the schema provides; its only mention of selectors is a restatement of 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 first sentence states a specific verb (Query) and resource (HTML elements in the active League client CEF UI DOM) with the mechanism (CSS selectors). It distinguishes itself from siblings by explicitly naming lol_eval and lol_cdp_screenshot as alternatives for different purposes.

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

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

The description provides explicit when-to-use (primary safe method to inspect live UI elements, verify modal state, find element identifiers), when-not-to-use (Do not use lol_eval when a CSS selector query suffices), and alternatives for adjacent tasks (lol_eval for arbitrary JS/state mutation, lol_cdp_screenshot for visual state). It also includes a prerequisite check via lol_status.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description adds genuine context beyond them: it enumerates what is returned (paths, HTTP verbs, functional groups, summaries) and notes it requires no live client connection. It omits result limits/pagination, keeping it short of a 5.

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 sentences, each load-bearing: purpose, return shape + usage, then the sibling redirect and prerequisite. Front-loaded with the core action and 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?

No output schema exists, but the description compensates by naming the returned fields (paths, verbs, groups, summaries). Combined with explicit sibling routing and the offline note, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100% and the single 'filter' param is fully documented there, including matching semantics. The description's keyword examples restate what the schema already provides, so baseline 3 is appropriate.

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

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

States a specific verb (search) and resource (curated catalog of LCU REST API endpoints), and explicitly distinguishes itself from the lol_schema sibling. An agent can tell what this returns without opening the schema.

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

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

Gives an explicit when-to-use ('quickly discover available endpoints by keyword') with concrete examples, an explicit when-not-to-use routing to lol_schema for schemas/parameter types/data models, and a prerequisite note that it works offline. Nothing 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 flag destructive/openWorld/non-idempotent, but the description adds critical context beyond them: unsandboxed, bypasses the write allowlist by construction, gated by the allowEval config flag (directing the agent to check lol_status), and requires an active CDP connection via Pengu Loader. This is exactly the behavioral disclosure an agent needs before calling a dangerous tool.

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

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

Front-loads the purpose, then uses CRITICAL/Behavior/Security/Prerequisite labels to structure the warnings efficiently. It is long, but nearly every sentence carries distinct, decision-relevant information.

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

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

For a 2-param tool with full schema coverage, rich annotations, and no output schema, the description covers purpose, alternatives, destructive/unsandboxed nature, the config gate, and the CDP prerequisite. An agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, with both `expression` and `awaitPromise` documented in the schema, so baseline is 3. The description implies single-expression evaluation and return of a result but adds no syntax or format detail beyond what the schema already provides.

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

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

States a specific verb+resource: execute an arbitrary JavaScript expression in the CEF renderer context and return the result. It explicitly distinguishes itself from siblings by naming what it is NOT for (LCU REST calls, DOM inspection, REST state queries).

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?

Explicit when-to-use/when-not with named alternatives: lol_get/lol_request for REST, lol_workflow_* for game actions, lol_dom_query for DOM, and reserves lol_eval for CEF runtime debugging and custom in-page automation. Nothing 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 declare read-only/idempotent/destructive=false, and the description adds real context on top: truncated-payload fallback via lol_get, and the meaning of a non-zero dropped count as buffer overflow between polls. That's behavioral insight the structured fields do not carry.

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?

Front-loaded with the core action and return, followed by usage routing, fallback behavior, and safety note. Every sentence carries distinct, non-redundant 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?

No output schema exists, yet the description explains the return (events and the new cursor), the dropped-count signal, and the truncation follow-up path. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the schema already documents all three parameters; the description reinforces the 'since' cursor as a cursor from the previous poll and ties limit/filter semantics into the poll flow. It adds meaningful framing beyond the schema, though it doesn't detail filter syntax.

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

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

States a specific verb-and-resource ('Drain buffered League Client WebSocket events') plus return semantics (events + new cursor). It distinguishes itself from lol_events_start and lol_wamp_record_dump, so an agent can identify it without opening any schema.

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

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

Explicitly says to use it 'to incrementally consume live client events after calling lol_events_start' and names the alternative for full frames (lol_wamp_record_dump). When-to-use, sequencing, and alternatives are all covered.

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 the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), and the description adds substantial behavioral context beyond them: in-memory ring-buffer eviction, the fact that calling while running updates URI filters and preserves buffered events, and the client-running prerequisite.

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

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

The description is front-loaded with its core purpose, then proceeds through usage, alternatives, behavior, and prerequisite in a dense but well-structured way. Every sentence provides routing or behavioral value, and there is no filler.

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

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

For a one-parameter start-buffering tool with no output schema, the description covers what the tool opens, what it buffers, how to consume the buffer, competing alternatives, ring-buffer limits, update behavior, and the client prerequisite. Nothing material is missing for 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 100%, so the filter parameter's syntax and default behavior are already documented. The description still adds meaning beyond the schema by clarifying that calling while running updates URI filters without discarding already buffered events, which is a useful lifecycle detail for that parameter.

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

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

The description states a specific verb and resource: opening the League Client WebSocket event tap and buffering live OnJsonApiEvent Create/Update/Delete notifications. It explicitly distinguishes this tool from lol_events_poll, lol_wamp_record_start, and lol_static, so an agent can route correctly without opening sibling schemas.

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

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

It gives clear when-to-use guidance for monitoring real-time client state changes and names concrete examples such as champ select, gameflow, and lobby updates. It also routes agents to alternatives for polling, raw WAMP recording, and static assets, and states the prerequisite that the League client must be running.

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 idempotentHint=true and destructiveHint=false, so the 'Idempotent; safe to call when already stopped' line largely repeats structured data. However, the description adds genuinely non-annotated behavior: buffered events remain readable via lol_events_poll after stopping, which tells the agent nothing is lost.

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?

Four short sentences, front-loaded with the action, then usage, then the alternative, then the behavior note. Slightly padded by restating the idempotency annotation, but otherwise every sentence 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?

A zero-parameter, non-destructive stop tool with no output schema needs only to say what it stops, when to use it, and what happens to buffered data — all of which are covered. Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4; there is no parameter semantics to document and the schema is complete by construction.

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

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

States a specific verb and resource ('Close the League Client WebSocket event tap and stop buffering live events'), and explicitly distinguishes itself from the sibling lol_wamp_record_stop. An agent can tell exactly what this does without opening a schema.

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

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

Gives the use condition ('pause or end event collection and conserve memory') and routes the agent to the correct sibling for the adjacent task ('For stopping WAMP recording, use lol_wamp_record_stop instead'). Nothing 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, idempotent, and non-destructive, so the safety bar is low; the description nonetheless adds genuinely new context that the operation 'does not interrupt background loggers or active streams' and works across concurrently recording streams. It stops short of describing cost, latency, or result volume for a cross-stream scan.

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

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

Three tight sentences, front-loaded with the scan scope and results. The trailing 'Behavior: Safe and read-only' slightly duplicates the readOnlyHint annotation, which is the only redundancy, but the side-effect clause in the same sentence earns its place.

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

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

With no output schema, the description usefully characterizes the kinds of anomalies returned, and the two optional parameters are fully specified in the schema. The remaining gap is the precondition that WAMP/CDP/disk loggers must already be recording for a cross-stream scan to yield anything, which is only hinted at by 'active'.

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

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

Schema description coverage is 100% and both parameters carry ranges, defaults, and enum values in the schema itself, so the description owes little here. It adds no extra meaning about how windowSeconds interacts across streams or how severityFilter maps to the listed anomaly classes, so the baseline 3 applies.

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

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

The description gives a specific verb ('Scans', 'detects') and enumerates the exact resource scope (LCU WAMP recordings, CDP console logs, network requests, client disk logs) plus the concrete findings returned (exception bursts, 500/503 clusters, WebSocket disconnects, fatal crashes). It never names or contrasts a sibling such as lol_forensics_correlate or lol_logs_tail, so the boundary against neighbors must be inferred.

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 is implied by the scanning/detection framing, and the mention of 'active' streams hints that recordings must be in progress, but there is no explicit when-to-use, when-not-to-use, or alternative tool guidance relative to lol_forensics_correlate or lol_logs_tail.

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?

'Safe and read-only' restates the annotations (readOnlyHint/destructiveHint), so that sentence earns little. However the description adds genuine behavioral value beyond annotations by disclosing the return contract ('Markdown report by default, or structured JSON when specified'), which matters because there is no output schema, and by explaining the includeLogTail fallback intent.

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?

Front-loaded purpose sentence followed by usage routing and return-format detail, with little waste. The 'Safe and read-only' clause is redundant against the annotations and is the one sentence that does not fully earn its place.

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

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

For a composite read-only aggregator with no output schema and six optional parameters, the description covers what it produces, when to prefer it, the alternative for narrower queries, and the output format contract. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so every parameter is already documented in the schema; the description implies the format, sources, and log-tail concepts but adds no syntax or defaults beyond them. Baseline 3 applies when the schema does the heavy lifting.

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 the specific verb 'Generate' and a concrete composite resource ('all-in-one diagnostic bundle') plus the three components it combines (connectivity status, correlated telemetry timelines, disk log tails). An agent can distinguish this aggregate tool from the many single-stream siblings without opening the schema.

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

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

Explicit when-to-use ('single-call comprehensive health check or bug report export when diagnosing complex client issues') and an explicit when-not with the named alternative ('For interactive querying of specific streams, use lol_forensics_correlate or subsystem-specific tools'). Routing is unambiguous.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description nonetheless adds non-obvious operational context: it combines active in-memory streams 'without interrupting background loggers,' which reassures the agent it won't perturb live capture. It stops short of describing result size limits or how streams are interleaved on timestamp ties.

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?

Four sentences, no filler: capability first, use case second, sibling routing third, behavioral guarantee last. Every sentence earns its place and the most important routing information is front-loaded before the alternatives.

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

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

For a 9-parameter aggregation tool with no output schema, the description covers what it merges, when to use it, and its safety/interruption profile. The one gap is that it doesn't indicate the volume or shape of results (e.g., bounded by limit, possibly narrative Markdown), leaving the agent to infer output characteristics from the format parameter 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 100% across all 9 parameters, so the schema already documents limit, since/until, format, levels, sources, logLevel, uriPrefix, and networkFailedOnly. The description's list of telemetry streams loosely maps to the `sources` enum, which is marginally helpful, but it adds no filter syntax or format-selection guidance beyond the schema. Baseline 3 applies.

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

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

States a specific verb ('Correlate') and enumerates the exact resources merged (LCU WAMP, CDP console logs, network requests, disk logs, live game telemetry) with the output shape (unified chronological timeline). An agent can distinguish this from every sibling without opening a schema.

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

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

Explicitly frames the use case ('during incident triage to identify whether client state changes triggered frontend UI errors or network failures') and routes to two named alternatives with their selecting conditions: lol_forensics_bundle for a full report and lol_cdp_console_tail for raw console logs 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?

The description explicitly states that, when savePath is supplied, the tool 'writes the formatted HAR file directly to disk' — a filesystem mutation (and potential overwrite of an existing file) that directly conflicts with the annotations readOnlyHint=true and destructiveHint=false. The description does add genuinely useful non-annotation context (automatic redaction of Basic/Bearer/Riot tokens, cookies and credentials), but the explicit write behavior contradicts the declared 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?

Three sentences, purpose front-loaded, no filler; each sentence carries information (scope, redaction, conditional I/O, prerequisite). Minor redundancy: the savePath branching restates the schema's own savePath description almost verbatim.

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 present, the description correctly compensates by saying what is returned (full HAR JSON structure) and what is stripped (auth headers, cookies, credentials), and it flags the prerequisite capture state. It never explains the 'limit' parameter or entry-count implications, and the write-to-disk claim conflicts with the provided annotations.

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

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

Schema coverage is 100% and the schema already documents both parameters, including savePath's conditional behavior in nearly the same words ('If omitted, returns the HAR JSON structure'). The description therefore adds no semantics beyond the schema for either parameter, and the 'limit' cap of 5000 entries is never mentioned. Baseline 3 is appropriate when the schema does the heavy lifting.

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+resource ('Exports captured HTTP/HTTPS network traffic') and names the exact output artifact ('standard HAR 1.2 archive'), which is far more precise than the title alone. It anchors the source ('active network tailer') so it cannot be confused with lol_cdp_network_tail, but it never explicitly contrasts itself with the other forensics exporters (lol_forensics_bundle, lol_forensics_correlate), so full sibling differentiation is absent.

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

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

It states an explicit precondition and the tool to call first ('Network recording must be active; call lol_cdp_network_start first'), and it explains the two modes of use (disk write when savePath is given, JSON return otherwise). It stops short of naming when NOT to use it or how it relates to the other forensics export 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 cover read-only, idempotent, open-world, non-destructive behavior, and the description adds operational context beyond them: the Live Client Data API on port 2999 must be active, and the default output is a compact summary to conserve tokens, with 'raw' returning a ~100KB payload. This tells the agent about prerequisites and response-size tradeoffs.

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?

Front-loads the purpose, then gives just enough routing guidance and behavioral context. The sibling alternatives and prerequisite are succinctly framed, and no sentence is wasted for a tool whose selection depends on match state and data scope.

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 rich annotations and a fully described single parameter but no output schema, the description covers selection context, prerequisites, and the summary-vs-raw output tradeoff. It does not detail the summary payload's exact structure, but it gives enough to choose the tool and format correctly.

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

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

Schema coverage is 100% and the single format parameter is documented in the schema, so the baseline is 3. The description adds some decision-relevant meaning beyond the schema by explaining that the default summary conserves tokens and that 'raw' yields the full ~100KB payload, though it largely reinforces the schema's summary/raw definitions.

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

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

States a specific verb and resource: 'Fetch complete real-time in-match game state' from the live League game engine, and enumerates the data it includes (scores, inventories, time, objectives, events). It also distinguishes itself from siblings by naming lol_game_player, lol_game_stats, lol_game_events, and lol_get for narrower needs.

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

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

Explicitly says when to use it ('during an active match to get full game telemetry') and names four alternative tools for specific needs (player details, clock/map only, events, client/lobby data). The prerequisite is also stated: the match must be currently running.

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 destructiveHint=false, so the safety profile is largely covered. The description adds real value by stating the prerequisite (active match on port 2999) and the incremental cursor behavior via afterId, which the annotations do not convey. A 4 reflects that it adds behavior beyond annotations without fully covering failure modes (e.g., what happens if no match is running).

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?

Four sentences, each carrying distinct information: purpose, usage, alternative, behavior, prerequisite. It is front-loaded with the core purpose. Slightly long but no sentence is filler, so it earns its size.

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, single-parameter tool whose annotations already cover safety, the description supplies the missing runtime prerequisite and cursor semantics. No output schema exists, but the description implies a list of events without detailing shape; that omission keeps it from a 5.

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

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

Schema description coverage is 100% and there is one optional parameter with a clear schema description. The description mentions 'Supports incremental cursor via afterId', which reinforces the schema but adds no syntax, format, or edge-case detail beyond it. Baseline 3 is appropriate when the schema already documents the parameter.

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

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

The description states a specific verb ('Retrieve') and resource ('in-game events'), and enumerates the event types (kills, objectives, turrets, aces). It distinguishes from the sibling lol_game_all, which is named as the broader alternative. It does not, however, differentiate from other lol_game_* siblings like lol_game_stats or lol_game_player as clearly as a 5 would require.

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

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

Explicitly states when to use ('track recent in-match actions or feed an event timeline') and names an alternative ('For full match state including player inventories, use lol_game_all instead'). It does not state when NOT to use it or contrast with lol_game_stats, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered; the description adds the non-obvious prerequisite that a match must be in progress (port 2999), which the schema does not convey. It stops short of describing the returned payload, so it is not fully complete.

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

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

Three tight sentences, front-loaded with purpose, then routing guidance, then the prerequisite. No filler or redundancy.

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

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

For a single-param read tool with no output schema, the description covers purpose, the sibling boundary, and the in-match prerequisite. It enumerates the returned stat categories but not the response shape, leaving a small gap that keeps it below 5.

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?

Only one parameter and schema coverage is 100%, so the schema already explains the summoner-name/local-player default. The description restates the same optional-name semantics without adding format or syntax detail, matching the baseline for a fully documented 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?

Specific verb ('fetch') plus resource ('real-time live match statistics, item inventory, abilities, and runes') for a scoped subject (local player or named summoner). It is clearly distinguishable from lol_game_all because the description names the alternative explicitly.

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?

States when to use it ('to inspect a specific player's current gold, level, KDA, items, or rune setup during an active match') and when not to ('For all players in the match at once, use lol_game_all instead'). The alternative sibling is named with the selecting condition.

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, and open-world, so the 'Safe and read-only' line adds little. However, the description goes beyond annotations with a real operational prerequisite ('Match must be currently running (port 2999)'), which tells the agent when the call will fail — valuable behavioral context.

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

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

Four short sentences, front-loaded with the verb+resource, then usage, then the alternative sibling, then prerequisites. Every sentence carries distinct information; nothing is padding.

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 returned fields (status, clock, mode, map ID) and the failure prerequisite, which is enough for correct invocation. It does not describe the error/empty response shape when no match is running, a minor remaining gap.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is no parameter syntax to explain, and the description correctly spends no space on 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?

States a specific verb and resource ('Fetch basic match status, game clock time, game mode, and map ID from the live League game engine') and enumerates exactly what is returned. It is clearly distinguished from the sibling lol_game_all, which is named as the broader 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?

Explicitly names three concrete use cases (verify a match is in progress, check elapsed time, identify game mode) and routes the agent to lol_game_all when full telemetry is needed. Both the when-to-use and the when-to-use-something-else conditions are stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety bar is met; the description adds real value beyond them by stating the return shape { status, body }, the client-running prerequisite, and that no write allowlist entry is needed. It stops short of describing error behavior (e.g., what happens on a 404 or malformed path), which keeps it from a 5.

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?

Four tightly packed sentences with zero filler: purpose/return first, then the positive alternative (lol_eval), then the mutating sibling, then path discovery and prerequisites. Front-loaded and every sentence earns its place.

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

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

No output schema exists, but the description compensates by naming the return shape, and it covers the prerequisite and the sibling routing an agent needs. For a single-parameter GET wrapper with full annotation coverage, nothing material is missing.

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

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

Schema coverage is 100% and the single path parameter is fully documented with a pattern and concrete examples in the schema. The description adds nothing about path syntax or format beyond 'any internal LCU REST API endpoint', so the baseline 3 applies.

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

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

States a specific verb (GET), resource (LCU REST API endpoint), and scope (read-only, any internal endpoint), and explicitly names what it returns ({ status, body }). It distinguishes itself from the mutating sibling lol_request and from lol_eval, so an agent can pick it without opening any schema.

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

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

Explicit routing: use this instead of lol_eval for inspecting live client state, use lol_request for POST/PUT/PATCH/DELETE, and use lol_endpoints/lol_schema to discover paths. It also names the prerequisite (client running) and the no-allowlist advantage. When, when-not, and alternatives are all covered.

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

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

The annotations already declare idempotent, non-destructive, and open-world behavior, so the description's 'Safe and idempotent' line is largely redundant. However, it adds useful operational context: avoiding duplicate processes, optionally polling for LCU readiness, and the installation prerequisite.

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

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

The description is front-loaded with the core action and remains compact. The standalone 'Behavior: Safe and idempotent' sentence is somewhat redundant with the annotations and the preceding sentence, but the overall structure is efficient.

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

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

For a launch tool with no output schema and rich annotations, the description provides the missing context an agent needs: launch mechanism, optional readiness polling, duplicate-process handling, and the installation prerequisite. Nothing essential for correct invocation appears to be missing.

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

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

Schema description coverage is 100%, and all three parameters are already well documented in the schema. The description reinforces the optional wait behavior and executable choices, but adds no syntax, format, or constraints beyond what the schema provides.

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

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

The description states a specific verb and resource: launching the League of Legends client via named executables. It also distinguishes the tool from diagnostic and automation siblings by focusing on process launch and LCU readiness.

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

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

It provides a clear prerequisite (League must be installed) and explains the already-running case, which effectively tells the agent when the tool is needed. It does not name alternative tools, but no sibling appears to offer the same launch capability.

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 safety is covered; the description restates 'Safe and read-only' but also adds genuinely new context: it scans standard Riot Games log directories on disk and returns results sorted newest-first. It does not detail failure modes (e.g., missing directories) or result shape, but the added environmental scope is meaningful.

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, front-loaded with what it lists and how results are sorted, followed by usage routing and a behavior note. No redundancy or 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?

For a two-parameter, zero-required discovery tool with no output schema, the description tells the agent what it returns (session identifiers/filenames), how it is ordered, and where it looks on disk. Only the concrete result fields are unspecified, which is minor here.

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

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

Schema coverage is 100%, and the schema already explains both the limit range and the target enum values with their meanings. The description only indirectly echoes the subsystem vocabulary ('Client, UX, or Game') and the session identifier hand-off, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('List historical and active ... log files on disk') with scope (three subsystems) and ordering (by modification time, newest first). It also implicitly differentiates from lol_logs_tail by describing itself as the discovery step.

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

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

Explicitly says when to use it (to discover session identifiers or filenames to pass into lol_logs_tail's session parameter) and names the alternative for the other intent ('For reading log content directly, use lol_logs_tail'). Both the use case and the exclusion are stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered structurally; the description reinforces this and adds a genuinely new trait: automatic redaction of passwords, tokens, and sensitive keys. It does not mention pagination or error behavior, but redaction disclosure is real added value.

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

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

Three tight sentences: purpose, usage routing, and behavior. The primary purpose is front-loaded and alternatives follow, with zero 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 and a fully documented 5-param schema, the description covers what an agent needs: purpose, routing, and the redaction guarantee. It stops short of describing return shape or how line counts map to output, but that gap is minor for a read-only tail tool.

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

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

Schema description coverage is 100%, so every parameter (level, lines, search, target, session) is already documented in the schema. The description adds only the notion of an 'active or selected' log file, which the schema's session description already implies, so baseline 3 is appropriate.

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

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

Starts with a specific verb+resource (read recent log lines) and scopes it to three concrete sources (League Client, CEF UX, Game engine disk log file). It clearly separates itself from siblings like lol_logs_watch_start/poll and lol_cdp_console_tail by naming them as different modes.

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

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

Explicitly states when to use it ('inspect historical or startup errors recorded on disk') and names two alternative tools with their distinguishing conditions (live streaming vs in-memory renderer console). An agent can route correctly without opening any schema.

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, but the description adds real value: the watch-start prerequisite, the empty-return condition when stopped, and duplicate-free cursor-based incremental polling. The only omission is any hint about ordering or return shape, which is minor.

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?

Front-loaded with the core purpose, then prerequisite, alternative, and behavior in a compact structure. The "Behavior: Safe and read-only" clause partly restates annotations, a small redundancy, but overall it is tight and earns its place.

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

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

For a 4-parameter read tool with no output schema, it covers purpose, gating prerequisite, the alternative sibling, and polling semantics. It does not describe the shape of returned entries, but with no output schema that is a modest gap rather than a blocking one.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning for the cursor parameter by explaining it as a sequence cursor enabling incremental, duplicate-free polling. The level/search/limit filters get no extra description beyond the schema, keeping this just above 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?

States a specific verb (poll) and resource (newly buffered disk log entries from the active watcher) with explicit scope (since a given cursor). It is clearly distinguishable from the sibling lol_logs_tail, which the description names directly.

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

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

Explicitly states when to use it (consuming real-time lines while watching is active), the prerequisite (lol_logs_watch_start must be running, empty if stopped), and the alternative for historical reads (lol_logs_tail). Nothing 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 declare the safety profile (destructive=false, idempotent=true, openWorld=true), so the bar is lower, yet the description still adds that the watcher uses an in-memory ring buffer that evicts oldest lines on overflow. That eviction behavior is a genuine trait not visible in the structured data. It does not describe the returned handle/session, which is a minor gap.

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

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

Front-loads the purpose, then layers the workflow (start -> poll -> stop) and the alternative. Every sentence carries distinct information with no redundancy.

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

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

For a stateful watcher with no output schema, the description covers the lifecycle and buffer semantics well. It leaves open how a started watch is identified for subsequent poll/stop calls, a small gap but one the sibling tools likely clarify.

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

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

Schema coverage is 100% and the sole 'target' parameter is fully documented with enum meanings in the schema. The description only refers generically to 'a log file' and adds no syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb (start watching) and resource (League Client disk log file) with the exact effect (newly appended lines streaming into an in-memory ring buffer). It explicitly distinguishes itself from the sibling stages lol_logs_watch_poll, lol_logs_watch_stop, and lol_logs_tail.

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 explicit when-to-use ('before reproducing an issue'), names the follow-up tools (poll, stop), and names the alternative for a different need (lol_logs_tail for one-off historical reads). The routing between siblings is unambiguous.

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

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

Annotations already declare idempotentHint=true and destructiveHint=true, so the safety profile is covered; the description reinforces this with 'Idempotent; safe to call when already stopped' and clarifies exactly what is torn down (file handles, in-memory buffer). It adds real context about what is destroyed, though it slightly restates the idempotency annotation.

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 tight sentences, front-loaded with the action and effect, then usage and behavioral note. No filler and no repetition of schema content.

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

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

For a zero-parameter teardown tool with no output schema and rich annotations, the description covers purpose, usage timing, and teardown semantics. An agent has everything needed to call it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-parameter tool is 4.

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

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

States a specific verb ('stop') and resource ('the active disk log watcher'), plus the concrete side effects (releasing file handles and the in-memory log buffer). This clearly distinguishes it from the sibling lol_logs_watch_start and lol_logs_watch_poll.

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

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

Explicitly states when to use it: 'to end log watching and free memory when debugging is complete.' The complementary start/poll siblings make the alternative obvious, but the description never names them as it does for other tools in this family.

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?

Goes beyond the annotations by disclosing the allowlist gate: GET/HEAD are always allowed, mutating verbs require matching allowlist entries, and unauthorized requests are rejected before execution. This is meaningful operational context not derivable from destructiveHint/openWorldHint. It stops short of describing the response shape or partial-failure 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?

Front-loads what the tool does, then alternatives, then behavior. Each sentence carries a distinct, decision-relevant fact and nothing is repeated from 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 generic escape-hatch tool with no output schema, the description covers purpose, alternatives, and the write-allowlist constraint. It would be stronger if it hinted at success/failure signalling or that responses are raw LCU JSON, but nothing critical to invocation is missing.

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

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

Schema description coverage is 100%, so method, path, and body are already documented in the schema, including the pattern for path and the note that body is omitted for GET/DELETE. The description adds no parameter detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (send an HTTP request with any verb) and resource (internal LCU REST endpoint), and enumerates the supported verbs. It is immediately distinguishable from lol_get, lol_eval, and the lol_workflow_* 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?

Explicitly routes the agent: prefer this over lol_eval for REST, prefer lol_get for safe reads, prefer lol_workflow_* for common automated actions, and use this for mutations or uncovered endpoints. When-to-use, when-not, and named alternatives are all present.

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?

Adds substantial context beyond the annotations: it discloses the destructive effect ('severs active CDP and WebSocket connections'), explains what waitForReady does (polling until LCU HTTP API and CDP page target are restored), and states the prerequisite that Riot Client and LCU must be running. This matches and enriches the destructiveHint/openWorldHint annotations rather than contradicting them.

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?

Front-loaded with the core action, then use-cases, exclusions, behavior, and prerequisite in a tight sequence. Slightly dense (a long parenthetical and a 'Behavior:' clause), but each sentence carries distinct routing or behavioral 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?

For a destructive mutation tool with no output schema, the description covers the action, its side effects, the sibling alternative, the recovery semantics of waitForReady, and the required prerequisites. An agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so both parameters (waitForReady, timeoutSeconds) are already fully documented in the schema, establishing a baseline of 3. The description restates waitForReady's polling behavior but adds no syntax or default information beyond the schema.

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

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

States a specific verb+resource ('Terminate and relaunch the League Client user interface frontend (Chromium Embedded Framework renderers)') with the mechanism (Riot Client API). It also explicitly distinguishes itself from lol_workflow_* siblings, so an agent can route without opening the schema.

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

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

Gives explicit when-to-use cases (frozen client UI, apply Pengu Loader plugin changes, reload corrupted UI states) and names the alternative for a different goal ('For gameflow or lobby navigation, use lol_workflow_* tools instead'). Nothing 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 declare readOnly, idempotent, openWorld, and non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: the live League client must be running and results are cached in memory after first load. No return-shape detail, but the input/output expectations are otherwise clear.

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?

Front-loads the core purpose, then routing alternatives, then the prerequisite. No redundant sentences; every clause earns its place.

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

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

No output schema exists, but the description names what you retrieve (signatures, parameters, request bodies, data models) and discloses the runtime prerequisite and caching behavior. An agent has enough to invoke it correctly; only the exact return format is left implicit.

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

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

Schema coverage is 100% with per-parameter descriptions (path keyword, model name, method enum, refresh flag), so the schema carries the semantics. The description adds only the general purpose of lookups ('find the exact request schema, parameter types, or response models'), which does not go much beyond the schema. Baseline 3 applies.

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

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

States a specific verb (Inspect) and resource (LCU API endpoint signatures, parameters, request bodies, data models) and ties it to the live OpenAPI/Swagger v2 spec. An agent can immediately distinguish it from lol_request, lol_endpoints, and lol_static without opening any schema.

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

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

Gives an explicit when-to-use ('before invoking lol_request') and names two alternatives with their selecting conditions (lol_endpoints for a lightweight list, lol_static for game assets). Routing is unambiguous.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so safety is largely covered. The description adds genuine value beyond that: the client-running prerequisite and the caching behavior of results, which the annotations do not express. It stops short of describing the failure mode when the client is not running, so not a full 5.

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?

Four tight sentences: purpose front-loaded, then usage, then alternatives, then prerequisite. Every sentence carries distinct, non-redundant information.

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

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

For a 7-parameter read tool with no output schema, the description covers purpose, routing, and the key operational constraint. It does not describe the return shape (default {id, name} plus optional fields) or pagination semantics for limit/offset, which the schema only partially implies, so a minor gap remains.

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

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

Schema coverage is 100% so the baseline is 3, but the description goes further by mapping raw ID types (championId, itemId, perkId, summonerSpellId, mapId, queueId) to the kind of document being queried, which clarifies the semantic link between the ids and kind parameters beyond the schema text.

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

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

States a specific verb (resolve) and resource (static game data IDs) and enumerates the exact ID kinds handled (championId, itemId, perkId, etc.), so an agent knows precisely what it produces. It also names the sibling tools it is not, making it distinguishable from lol_get and lol_schema without opening schemas.

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

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

Explicitly says when to use it (translating raw IDs from other tools or telemetry), names the alternatives for adjacent cases (lol_get for live client state, lol_schema for OpenAPI models), and states the prerequisite that the League client must be running. Nothing 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 declare readOnlyHint, idempotentHint, and destructiveHint=false, so the description's 'Safe and read-only; requires no client write permissions' is largely redundant. It adds the subsystem coverage list but discloses nothing about cost, latency, or what a failed subsystem looks like in the 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?

Front-loaded with the scope statement and diagnostic guidance in two tight sentences. The trailing 'Behavior:' clause repeats annotation data rather than earning its place, a minor inefficiency.

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 diagnostic tool with no output schema and no parameters, the description should hint at what the status report contains (per-subsystem fields, error indicators). It names the subsystems inspected but leaves the agent guessing about the return shape.

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

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

The tool takes no parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate. No parameter-level guidance is needed or missing.

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

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

States a specific verb (inspect) and enumerates the exact resources covered: LCU REST/WebSocket, CDP, event buffers, live game engine. This scope enumeration clearly distinguishes it from narrow siblings like lol_chat_status or lol_cdp_targets.

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 concrete activation contexts ('use this tool first when diagnosing connection failures', 'verifying lockfile detection', 'checking allowlist rules and allowEval permissions'). Strong when-to-use guidance, though it names no alternative or when-not-to-use condition.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior, but the description adds substantial context beyond that: it discloses the returned data shape (timestamped entries, dropped frame count, cumulative stats surviving eviction), the prerequisite, and the diagnostic purpose. No behavioral traits are contradicted.

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 front-loaded with the core purpose, followed by usage context, prerequisite, alternative, and behavior. Every sentence contributes useful information without redundancy or 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?

Given six optional parameters, full schema descriptions, a meaningful annotation set, and no output schema, the description supplies the necessary context: what it returns, when to use it, the prerequisite, and an alternative tool. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so all six parameters are fully documented in the input schema with descriptions, enums, ranges, and pagination semantics. The description adds no parameter-specific syntax or meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource ('Retrieve recorded WAMP timeline entries, socket lifecycle events, and cumulative per-URI statistics') and clearly distinguishes this from sibling tools by naming an explicit alternative for broader correlation. An agent can identify the tool's scope without opening the schema.

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

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

It states when to use the tool ('inspect recorded WebSocket frames and diagnose whether a quiet URI received no traffic or the socket disconnected'), gives the prerequisite ('lol_wamp_record_start must have been called'), and names an explicit alternative for a different use case ('For general timeline correlation across multiple subsystems, use lol_forensics_correlate').

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 declare a mutation (readOnlyHint=false, destructiveHint=true, idempotentHint=false), and the description adds real behavioral context beyond them: what is captured (open/close with exit codes, errors, reconnect gaps, frames) and the error condition for a double-start. It stops short of covering cost, auth, or connection lifetime, so not a full 5.

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?

Front-loaded with the action, then usage, then a labeled 'Behavior:' block — well organized and no filler. Slightly long due to the enumerated capture list, but every clause carries information.

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

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

With no output schema, the description still tells the agent what is collected and where to retrieve it (lol_wamp_record_dump) and pairs with lol_wamp_record_stop as its lifecycle counterpart. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is already 100%, so the baseline is 3. The description earns an extra point by explaining the restart semantics operationally ('throws an error unless restart is true'), which clarifies the consequence of the flag beyond the schema's phrasing.

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 verb and resource ('Open a dedicated secondary WAMP WebSocket connection... record raw frames') and states the scope precisely. It actively distinguishes itself from lol_events_start (lightweight polling) and points to lol_wamp_record_dump for retrieval.

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

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

Explicit when-to-use cases are given (deep protocol diagnostics, debugging connection drops, analyzing message flows) plus a named alternative for the lighter use case ('prefer lol_events_start instead') and the follow-up tool for dumping. This is textbook routing guidance.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false and openWorldHint=true, so the safety profile is fully covered by structured data. The description's 'Idempotent; safe to call when already stopped' largely restates the annotation; the only genuinely additive behavioral fact is that captured entries persist and can be retrieved via the dump tool.

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

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

Three short sentences, each earning its place: purpose first, then the usage trigger, then the retrieval path and safety note. No filler or restated tool name beyond the opening verb.

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 stop tool with rich annotations and no output schema, the description covers what it does, when to call it, that it is safe to repeat, and where the captured data lives afterward. Nothing an agent needs to invoke it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline of 4 applies. The description correctly does not invent parameter detail where none exists.

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

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

States a specific verb and resource: 'Terminate the dedicated WAMP recorder WebSocket connection and halt traffic capture.' This clearly distinguishes it from the sibling lol_wamp_record_start and lol_wamp_record_dump without needing to open any schema.

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

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

Explicitly names the trigger ('when WAMP diagnostic recording is finished') and routes the agent to the correct alternative for retrieving results ('Recorded entries remain accessible via lol_wamp_record_dump'). It also pre-empts the redundant-call question by noting it is safe to call when already stopped.

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