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

With no annotations, the description carries the behavioral burden. It discloses that the tool reports counts over cached games only and distinguishes analysed from pending, which is useful, but it does not explicitly confirm read-only behavior, permissions, or what the return values look like.

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

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

The description is a single front-loaded sentence with zero wasted words. It states the metric immediately and is appropriately sized for a simple status 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?

For a simple one-parameter query with no annotations or output schema, the description is minimally adequate: it conveys what is counted. However, without an output schema, it should ideally clarify the return shape or explicitly state that it does not trigger analysis.

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

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

Schema description coverage is 0% for the single username parameter. The description adds only that the username identifies a player, but does not specify format, case sensitivity, or any other semantic detail beyond the schema's property 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?

The description clearly states a specific metric: counts of a player's cached games that are analysed versus pending. It is distinct from siblings like analyze_games or sync_games, but it does not explicitly name those alternatives or clarify the boundary.

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 as a status-checking query, but the description gives no explicit guidance on when to use this tool versus list_games, analyze_games, or sync_games. There are no exclusions or prerequisites.

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

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

With no annotations, the description carries the burden and does well: it discloses the batch/short-call cost model, the continuation pattern, and that it 'Returns progress counts only' rather than analysis output. It omits whether motif tagging persists data or what permissions/engine resources are required.

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 core action, then behavior and prerequisite. No filler, though the 'call again to continue' fragment is slightly under-integrated.

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 and no annotations, yet the description covers return shape, batching, continuation, and ordering. Only missing pieces are persistence/permission details for the motif tagging it performs.

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

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

Schema coverage is 0%, so the schema names batch_size and max_seconds without explaining them. The description hints at their meaning ('works in small batches so one call stays fast') but never maps that to the parameters or mentions defaults (25, 45).

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 (analyse with Stockfish), the exact resource scope (not-yet-analysed games, newest first), and a secondary effect (tagging costly moves with motifs). This clearly separates it from sync_games (downloads) and tag_motifs (tagging).

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 prerequisite ('Use sync_games first to download games') and an iteration contract ('call again to continue'), plus a pointer to tag_motifs for the motif side. It stops short of stating when not to use it, but the ordering constraint 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?

With no annotations, the description carries the behavioral burden and discloses important traits: only costly moves and near-decided positions are re-searched, stored evaluations are never changed, and the operation works in batches. It omits permissions, resource limits, and interruption behavior, but the core mutation behavior is well described.

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 behavioral constraints, then the batching loop. Every sentence adds 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?

There are no annotations and no output schema, and the input schema lacks parameter descriptions. The description covers purpose, core behavior, and batching well, but leaves significant gaps around parameter semantics and does not explain what backfill_pending is or where it is returned.

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

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

Schema description coverage is 0%, so the description must explain username, batch_size, and max_seconds. It only hints at batching and mentions an external backfill_pending value; it never explains the required username or the meaning/impact of max_seconds.

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

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

The description states a specific action: add mate scores and best-line (PV) data to previously analysed games so get_game can display them. This clearly distinguishes the tool from siblings like analyze_games or sync_games by scoping it to historical backfill rather than new analysis or syncing.

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 explains the core use case — enriching old games so get_game can show missing details — and gives an explicit operational loop: call again until backfill_pending is 0. It does not name alternatives or when-not-to-use cases, but the intended context 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?

No annotations are provided, so the description bears the full disclosure burden. It usefully explains the report's contents (causes, focus, trend) but does not state that it is read-only, whether it depends on prior analysis/sync steps, or what the response format is.

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

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

The description is two sentences and front-loads the entry-point cue ('Start here'). The output summary is dense but purposeful, with no redundant restatement of the title or name.

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

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

There is no output schema and no annotations, and the input schema has zero description coverage. The description covers the report's outputs and sibling relationship but leaves all parameter semantics and operational prerequisites unexplained, so an agent cannot fully determine how 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 0% across three parameters, and the description never mentions username, time_class, or recent_games. It adds no meaning about defaults, valid values, or how inputs affect the report.

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

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

The description identifies this as the entry-point coaching report: it explains losses, gives one weekly focus with evidence, and shows a trend against earlier games. It distinguishes itself from siblings by telling the agent to use 'the other reports to drill into the focus area,' though it describes outputs rather than naming a specific action verb.

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

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

'Start here' is an explicit routing instruction, and 'Use the other reports to drill into the focus area' clarifies when to use siblings instead. It lacks explicit preconditions such as requiring synced or analyzed games, but the selection guidance is strong.

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

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

No annotations are supplied, so the description carries the full burden and leaves key behavior unstated: whether the tool is read-only, whether it requires prior sync_games/backfill_game_details runs, how expensive the computation is, or any pagination/limits on the returned games. It does describe the report's sections, which is some credit, but not the operating characteristics.

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

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

It is front-loaded with the population definition, which is the right ordering, but it is a single run-on sentence with nested parentheticals and a trailing orphan clause about collapse_type. Dense but not well structured.

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

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

For a 6-parameter analytic tool with no output schema and no annotations, the description does enumerate the report's contents (frequency, endings, collapsing move with phase/clock/motifs, drop-below-50 point, newest n games), so return content is reasonably covered. Parameter meaning and prerequisites remain 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?

Schema description coverage is 0% across 6 parameters, so the description must compensate and only partially does: 'threshold' and 'n' are explained in passing, but 'color', 'last_n', and 'time_class' are never mentioned, and the relationship between 'n' and 'last_n' is left ambiguous. Half the parameters remain opaque.

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 precisely defines the population the report covers (games where win chance crossed the threshold but no win resulted) and enumerates the outputs, which distinguishes it from weakness_report and generic analysis tools. However, it never states an operational verb ('analyze', 'aggregate') and reads as a data definition rather than a description of what calling the tool does.

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

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

There is no when-to-use guidance and no routing against the many overlapping siblings (missed_opportunities, weakness_report, worst_moments, tilt_report). weakness_report is mentioned only to define the threshold-counting rule, not as an alternative to choose between.

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

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

With no annotations, the description carries the full behavioral burden and does so richly: it discloses cached/no-engine behavior, evaluation perspective, clipping, rounding, class thresholds, mate-field semantics, only_flagged filtering, motif semantics, clock null behavior, and what an unanalysed game returns.

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 long but front-loaded and dense with useful conventions. Every section earns its place by clarifying return values, filtering, or edge cases, and there is no fluff.

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

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

Given no output schema and no annotations, the description is largely complete for interpreting the game data and its edge cases. It falls short of full completeness because include_pv is undocumented and there is no explicit read-only or error-handling note.

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

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

Schema coverage is 0%, so the description must explain parameters, and it does well for game, username, ply_from/ply_to, and only_flagged. The notable gap is include_pv, which is never mentioned despite affecting the returned PV data.

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 and resource: retrieve one cached game move by move from stored analysis, explicitly noting no engine is run. That scope distinguishes it from analyze_games and list_games even without naming them.

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

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

Usage is implied by the opening scope and parameter notes, such as using this to read an already-analysed single game and passing username to set meta.my_color. However, it never explicitly says when to choose this over siblings like list_games, analyze_games, or worst_moments, nor when not to use it.

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

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

With no annotations, the description must carry the whole behavioral burden. It discloses that results come from a cache and are ordered newest-first, and that the opening filter is a case-insensitive substring match. It does not say whether the cache can be stale, how n interacts with 'newest first', or what an empty result means.

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 scope, ordering and the get_game linkage; filters follow in a single compact line. The long return-field enumeration is justified because no output schema exists, though it could be trimmed to the fields an agent actually needs to pick a game_id.

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?

Without an output schema, the description correctly supplies the return shape and filter semantics, which is most of what an agent needs. Gaps remain around n (pagination/limit behavior) and cache freshness relative to sync_games, which matter for a data-retrieval 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 coverage is 0%, so the description must compensate, and it largely does: time_class, color, result (explicitly framed as from the player's side) and opening are all given value semantics and allowed values. The required username is only implied via 'the player's', and n is never mentioned at all.

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

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

States a specific verb+resource (list the player's cached games), gives ordering (newest first), and states its downstream purpose (to find a game_id for get_game). The word 'cached' implicitly separates it from sync_games, and 'find a game_id' separates it from get_game itself.

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: call this to obtain a game_id before calling get_game, and lists filter dimensions with accepted values. It does not say what to do when the cache is empty or stale (presumably sync_games), so the exclusion/alternative guidance is incomplete.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one useful detail—`missed_mates` are ordered shortest mate first, then newest—but omits data scope, authentication needs, return behavior, and how `n`/`last_n` affect results.

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

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

The description is compact and front-loads the main purpose before the `missed_mates` detail. There is little waste, though the phrasing is slightly dense and could be clearer about the report structure.

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 four-parameter analysis report with no output schema, no annotations, and 0% schema description coverage, the description is materially incomplete. It explains the concept and one output field ordering but does not cover parameter meaning, usage conditions, or report scope.

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

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

Schema description coverage is 0% and the description does not explain any of the four parameters. `n`, `last_n`, `username`, and `time_class` remain semantically undocumented beyond their bare types/defaults, so the description fails to compensate for the schema gap.

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

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

The description states a specific analytical purpose: measuring how often the player capitalized on opponent blunders and summarizing costliest missed chances, plus a specific `missed_mates` ordering rule. It does not differentiate itself from related siblings such as `worst_moments` or `conversion_report`, so it falls short of a 5.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like `worst_moments`, `conversion_report`, or `tilt_report`. Usage is only implied by the metric name and description, leaving the agent to infer selection criteria.

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

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

With no annotations, the description carries the full burden, and it does disclose important behavioral quirks: a move can carry several tags so shares can exceed 100%, untagged_share_pct covers unexplained moves, min_class values are 'mistake' or 'blunder', and pending_moves flags untagged games. It does not state that this is a read-only operation or discuss cost/latency, so the safety profile is only implied by the word 'report'.

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 content is dense but front-loaded, leading with what the report counts and following with caveats about overlapping tags and untagged moves. Every sentence contributes; the only mild inefficiency is the slightly run-on opening clause.

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 report tool with no output schema and no annotations, the description explains the output shape reasonably well but leaves several filters (last_n, time_class, username) undocumented. An agent can understand the report's content but cannot confidently map all parameters.

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

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

Schema coverage is 0% across 7 parameters, so the description must compensate. It clearly defines min_class and implies domains for phase, colour and pace (hasty/considered/short of time), and n_examples is hinted at by 'newest and costliest examples of each', but username, last_n and time_class are never explained, leaving meaningful gaps.

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

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

The description states specifically what the report contains: counts, share and average win-chance loss per motif tag, split by phase, pace and colour, plus newest and costliest examples. This distinguishes it from siblings like weakness_report or tag_motifs, though it describes output content rather than opening with a clean verb+resource 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?

It names one alternative/prerequisite explicitly: pending_moves counts costly moves in games not tagged yet and 'run tag_motifs' to tag them. That is useful routing, but there's no guidance on when this report is preferred over weakness_report, analyze_games, or worst_moments, and no exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds the useful sorting detail 'worst first', but says nothing about permissions, data prerequisites, whether games must be synced first, or how 'opening-phase quality' is computed.

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

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

The description is a single efficient sentence with no filler, and the key subject (results and opening-phase quality) is front-loaded. It is appropriately sized, though its terseness is better addressed as a completeness gap than as a conciseness problem.

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

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

This is a parameterized report tool with four inputs, no annotations, no output schema, and zero schema descriptions, so the description should do much more. One sentence cannot explain parameter meaning, data requirements, or what the report returns.

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

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

Schema description coverage is 0% and the description never mentions any of the four parameters (username, last_n, min_games, time_class). It fails to compensate for the undocumented parameters, leaving the agent with no semantic guidance beyond the bare schema titles.

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

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

The description names a specific report type: results and opening-phase quality, segmented by opening and colour, sorted worst first. This is clear enough to distinguish it from siblings like time_of_day_report or weakness_report, though it does not explicitly name any 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?

There is no guidance on when to use this tool versus alternatives such as weakness_report or motif_report, and no prerequisites or exclusions are stated. The agent is left to infer usage entirely from the one-sentence description.

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

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

With no annotations, the description carries the full burden and does disclose useful behavior: the comparison uses medians and quartiles from public games, sample sizes are shown per rating band, and thin bands are flagged tentative with no verdict. It does not mention permissions, rate limits, or explicitly state that the operation is read-only, so it falls short of the richest 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?

The description is two efficient sentences with the primary purpose front-loaded and the sample-size caveat placed immediately after. Every sentence adds value, and there is no repetition 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?

There is no output schema and no annotations, so the description must carry return and behavioral context. It explains the comparison basis and the tentative-band limitation, but 'blitz numbers' is vague and the returned metrics/format are not defined. It is enough to invoke with a username, but leaves real ambiguity about what the comparison output contains.

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

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

Schema description coverage is 0%, so the schema only indicates a required 'username' string. The description's phrase 'the player's' implicitly maps to that parameter but never names it, describes its format, or adds constraints. For a single obvious required parameter this is minimally adequate, but it does little to compensate for the missing schema descriptions.

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

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

The description gives a specific verb ('Compare') and resource ('the player's 3+0 blitz numbers') against a clearly defined benchmark ('players of other rating bands'). It is unambiguous about the peer-benchmarking focus, though it does not explicitly name or differentiate itself from sibling report tools.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative sibling tool is named. The first sentence implies a peer-benchmarking use case, but the agent must infer when to select it over reports like weakness_report or coach_plan.

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

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

No annotations are provided, so the description carries the full burden, yet it says nothing about whether this is a read-only precomputed lookup or an expensive on-demand computation, what the result looks like, or whether it requires prior game analysis. Only the semantic definition of the metric is disclosed.

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

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

A single tight sentence with zero padding, and the definition is front-loaded. But it is a fragment that omits the operative framing (a report for a given player), so brevity comes at the cost of completeness rather than being purely 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?

With no annotations, no output schema, and two undocumented parameters, the description must do more. It never explains return shape, prerequisites, or the time_class filter, leaving the agent with a metric definition but insufficient guidance to invoke the 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?

Schema description coverage is 0% for two parameters. The description's word 'player' weakly implies the username scope, but time_class (default null, anyOf string/null) is never addressed, so an agent cannot tell what values it accepts or how it filters the report.

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 sentence defines the metric concretely — wins/draws from a clearly worse position — which adds real meaning beyond the name 'resilience_report'. However, it is a noun phrase with no verb, and it never states that this produces a per-player report for a supplied username, nor distinguishes it from siblings like tilt_report or conversion_report.

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

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

There is no indication of when to call this versus the many adjacent reports (weakness_report, tilt_report, conversion_report, peer_comparison). No prerequisites are mentioned, even though siblings like analyze_games and analysis_status suggest analysis may need to exist first.

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

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

With no annotations, the description carries the full behavioral burden and does contribute one genuinely useful trait: the ~10:1 false-positive ratio, which tells the agent to treat results as leads, not conclusions. It omits whether the tool is read-only, whether it requires prior analysis, how much of the game history is scanned, and what the ordering/volume of results looks like.

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

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

Two tight sentences, purpose front-loaded, and the reliability caveat immediately after. Nothing is wasted and nothing is repeated from structured fields.

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 four-parameter tool with no annotations and no output schema, the description covers purpose and precision only. Missing are the prerequisites (synced/analyzed games), what the filters do, and any notion of result shape or count, leaving real gaps before an agent can invoke it confidently.

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

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

Four parameters with 0% schema description coverage, and the description explains none of them: n, last_n, time_class, and even username are undefined. At best 'over-reports ... candidates per real brilliant' vaguely implies the result set that n presumably bounds, but that is an inference the agent should not have to make.

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 concrete finding: it surfaces moves that offer a piece up, and ties that to a known concept (chess.com 'brilliant'). An agent can tell this is a candidate-finding tool, though it never says it scans the calling user's analyzed games, so the resource scope has to be inferred from the username parameter.

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

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

There is no statement of when to reach for this versus analyze_games, motif_report, missed_opportunities, or worst_moments, no prerequisites (does it need sync_games/analyze_games to have run first?), and no exclusions. The precision caveat hints at suitability but is a behavior note, not usage routing.

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

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

With no annotations, the description carries the full load and does well: it discloses idempotency (cached games skipped), a data filter (standard chess only), the side effect (writes to local cache), and the response shape (counts, not games). It omits failure behavior and any rate-limit/API-auth considerations, which is what 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 short sentences, front-loaded with the core action, then constraints, then return shape. Nothing is redundant and every sentence adds information the agent needs.

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

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

For a two-parameter write-to-cache tool with no annotations and no output schema, the description covers action, side effect, idempotency, filtering, and return type. The notable gap is the unexplained `months` window and any error/partial-failure behavior.

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

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

Schema coverage is 0%, so the description must explain both parameters. It says "recent games" but never mentions the `months` parameter that defines that window (default 3), leaving the most consequential parameter undocumented in both schema and prose.

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 (download a player's recent games) plus a target (local cache) and a scope constraint (standard chess only). This clearly separates it from read tools like list_games and get_game, which the closing sentence implicitly contrasts with.

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?

"Already-cached games are skipped, so it is safe to call repeatedly" implies this is a cache-priming step safe to run before analysis, and "returns counts, not the games themselves" hints that reading games requires another tool. However, no sibling is named and no explicit when-to-use / when-not-to-use rule is given.

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

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

With no annotations, the description carries the burden well: it discloses that Stockfish is only consulted for a ply without a stored line, once, at a fixed depth, and that engine_searches reports how many such calls occurred - key cost/behavior information. It does not say whether tagging persists/overwrites prior tags or is idempotent, which a mutation-style tool should clarify.

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 and the full tag vocabulary (necessary since the schema has no enum), then the iteration semantics, then the engine-cost caveat. Dense but every sentence contributes; only the long enumeration makes it heavy.

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, and the description proactively names two response fields (motif_pending, engine_searches) plus the termination condition. The remaining gap is parameter documentation for a 3-param tool with zero schema coverage.

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

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

Schema coverage is 0%, so the description must compensate, yet it never explains username, batch_size, or max_seconds explicitly. 'In batches' hints at batch_size and engine cost hints at max_seconds, but an agent must guess that max_seconds is a time budget for the call and what units/limits apply.

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 concrete verb+resource: tagging the costly moves of analysed games with one of ten named error categories, and it names sibling-adjacent concepts (stored analysis, Stockfish fallback) that separate it from analyze_games and motif_report.

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 operational guidance for repeated invocation ('Newest games first, in batches; call again until motif_pending is 0') and clarifies it reads stored analysis rather than recomputing, but never states the prerequisite (games must already be analysed by analyze_games) or when to prefer motif_report 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?

With no annotations at all, the description carries the full disclosure burden, and it does add real behavioral content: games are bucketed into sessions at pause boundaries, and differences are suppressed unless they exceed sampling noise (a significance filter). It says nothing, however, about required data availability, cost/runtime, what metrics are compared, or whether any state is mutated.

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 the analytical question, followed by the session definition and the significance caveat. No filler, though the opening interrogative form is slightly less actionable than an imperative verb phrase would be.

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 multi-parameter analytics report with no annotations, no output schema, and zero schema descriptions, the description covers the conceptual model well but leaves the agent guessing about return shape, metric definitions, and parameter value formats. Adequate to understand intent, insufficient to call confidently without opening the schema.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It only implicitly explains session_gap_minutes ('a pause longer than the gap starts a new one') and says nothing about username or time_class (e.g., allowed time-class values or default behavior), leaving most parameters undocumented in both schema and prose.

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 poses the exact analytical question the tool answers ('Does the player play worse after losses, or later in a session?'), which effectively communicates that this is a tilt/session-performance report. It is distinguishable from most siblings in spirit, though it never names or contrasts itself with adjacent tools like resilience_report or worst_moments, so the differentiation is implicit rather than stated.

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 framing question — an agent can infer this is the tool for loss-streak/session-position effects — but there is no explicit when-to-use statement, no exclusions, and no routing to alternatives such as resilience_report. The session-grouping sentence provides context for how the analysis is scoped, which is partial guidance rather than a usage policy.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one useful behavioral trait — the analysis uses the local clock, so results depend on timezone — but it doesn't state that this is a read-only analysis, what the response contains, or any auth/rate-limit context for a username-scoped report.

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

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

A single front-loaded sentence with no filler, so it is very efficient. The brevity is also part of the problem, but as pure conciseness it 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 analytical report with no output schema and no annotations, one sentence is thin. The unexplained `time_class` parameter and the absence of any usage or output context leave an agent guessing how to filter the report and what to do with results.

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

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

Schema description coverage is 0%, so the description must compensate for two undocumented parameters. It never explains `username` (required, presumably the player under analysis) or the optional `time_class`, which is an anyOf string/null with no enum and no meaning given anywhere; the phrase 'time of day' only vaguely gestures at it.

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

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

The description names the resource (a report) and the two specific dimensions it breaks down: results/blunder rate by time of day and by weekday vs weekend. That is a clear verb-equivalent and scope, distinguishable from time_pressure_report or tilt_report, although it never explicitly contrasts itself with those 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling report tools. A reader must infer that this is the tool for scheduling/clock-time analysis, but nothing states the condition that selects it over time_pressure_report or tilt_report.

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

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

With no annotations, the description carries the burden, and it does disclose the shape of what comes back (per-zone error breakdowns, hasty vs considered blunders, phase timings, losses on time). However, it says nothing about whether it reads cached/synced data, whether it triggers computation, cost or latency, or whether a missing username returns 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?

A single front-loaded sentence that leads with the core question ('how the clock affects a player's results') and then itemizes the deliverables. No filler, though the sentence is one long list with no separate guidance section.

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 annotations, no output schema, and 0% parameter coverage mean the description should do more for a 3-parameter analytical tool. It describes report contents but not the filtering behavior of last_n/time_class or any data prerequisites, leaving key invocation decisions unaddressed.

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

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

Schema description coverage is 0% for all three parameters, so the description must compensate and largely doesn't. 'A player's results' weakly implies username, but last_n (recency window) and time_class (bullet/blitz/rapid filter) are entirely unexplained in both schema and description.

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

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

The description enumerates concrete report contents (errors by time-pressure zone, hasty vs considered blunders, time per phase, games lost on time), which makes the tool's resource distinctly about clock management rather than, say, tilt or openings. It's clear what the report covers, though the verb is implicit ('report') and no sibling is named.

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

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

There's no when-to-use framing, no prerequisite (e.g. games already synced), and no pointer to alternatives among the many sibling reports (tilt_report, resilience_report, worst_moments). An agent must infer that this is the clock-focused report from the content list 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that results are based on analysed games and can be scoped by time class and recency, but it does not state prerequisites such as whether games must first be analysed or synced, whether there are minimum sample requirements, or what happens when no analysed games match the filters.

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

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

The description is two compact sentences, front-loaded with the report's purpose and followed by the optional scoping parameters. Every sentence contributes useful information with no repetition or fluff.

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

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

The description gives enough information to understand what the report covers and how to scope it. However, for a report tool with no annotations and no output schema, it omits prerequisites, expected return structure, and guidance on how this report relates to closely overlapping siblings, leaving some contextual gaps.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaningful semantics for time_class by giving bullet/blitz/rapid examples and for last_n by explaining that it limits to the most recent N analysed games. The username parameter is self-evident and needs no further explanation.

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

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

The description clearly states the report's purpose: showing where a player loses most by game phase, colour, time control, and how often winning positions are thrown away. It is specific enough to distinguish the report from many siblings, though it does not explicitly name alternatives or explain how it differs from closely related reports like conversion_report or resilience_report.

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 opening phrase implies the use case: diagnosing where a player loses most. The second sentence explains optional scoping by time class and recent analysed games, which is useful usage context. However, there is no explicit guidance on when to choose this report versus sibling reports or when not to use it.

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

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

No annotations and no output schema, so the description carries the full burden. It discloses the returned fields (FEN, played move, best move), which is useful, but says nothing about what 'costliest' means (eval swing? win-probability?), what 'confirmed' implies (engine depth?), or whether this requires prior analysis via analyze_games.

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

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

A single tight sentence with the key fields front-loaded behind the resource qualifier. Underspecified rather than bloated, so only a small deduction for terseness that omits needed routing and parameter context.

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 tool with zero schema coverage, no annotations, and no output schema, the description leaves out how blunders are ranked, how n and last_n interact, and what analysis state is assumed. It is not complete enough to invoke confidently without guessing.

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

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

Schema description coverage is 0% across 4 parameters, and the description compensates only weakly: 'the player's' hints at username, but n, last_n, and time_class receive no explanation anywhere. The critical distinction between n (count) and last_n (game window) is left entirely ambiguous.

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 resource with a clear qualifier: the player's costliest confirmed blunders, plus the returned fields (FEN, move played, best move). This distinguishes it reasonably well from report-style siblings like weakness_report, though it doesn't explicitly contrast with missed_opportunities.

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

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

No guidance on when to pick this over missed_opportunities, weakness_report, or sacrifice_candidates, all of which plausibly surface similar material. No prerequisites or exclusions are stated.

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