DunkAPI

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false. The description adds valuable non-schema behavior: it costs 5 credits and includes explicit compliance constraints around market information, which are important for correct use beyond what annotations provide.

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

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

The description is four tight sentences with no waste. It front-loads the return contents, then covers the sibling alternative, cost, and compliance constraint in a logical order.

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 full schema coverage, rich annotations, and an output schema, the remaining burden on the description is low. It still explains the data scope, cost, sibling alternative, and market-information restriction, leaving no significant gap 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 game_id and league are fully documented in the schema itself. The description reinforces that this is for one game but adds no syntax, format, or enum meaning beyond the schema, making the 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?

The description states exactly what a call returns: a single game in full, including score, both teams' box scores, every player's line, each sportsbook's opening and closing line, and win-probability range. It also explicitly distinguishes this from get_plays, so an agent can route between 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?

It gives clear usage context ('Use for one game in full') and explicitly names the alternative for play-by-play ('For the play-by-play use get_plays'). It does not address overlap with siblings like get_odds or get_line_movement, but the primary routing decision is 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 establish read-only, idempotent, non-destructive, and non-open-world behavior. The description adds useful operational context beyond annotations: a cost of 2 credits and the temporal snapshot rule that data is captured on the latest day or the latest on or before the given date.

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

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

The description is compact and front-loaded: it begins with explicit usage, then defines report contents, date behavior, league scope, and cost. Every sentence carries useful information with 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?

Given the full schema coverage, rich annotations, and the presence of an output schema, the description is complete enough for correct invocation. It covers purpose, date semantics, league scope, and cost without needing to explain return-value structure.

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 are already documented in the schema. The description reinforces the date semantics and league scope but does not add team-filter semantics or other meaning beyond what the schema provides, making the 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?

The description names a specific resource, the injury report, and enumerates its core contents: player status (out, day-to-day), injury, and expected return. It also scopes the tool to NBA and WNBA and clarifies the as-of-date behavior, so an agent can identify the tool's purpose immediately.

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 explicitly says 'Use for the injury report,' giving clear context for selection. It also explains the date fallback behavior, though it does not state when not to use it or name alternatives, which is less critical here because no sibling tool covers injuries.

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, closed-world and non-destructive, so the safety profile is covered. The description adds what annotations cannot: a concrete cost of 5 credits and the fact that results are aggregated from every box score, which matters for budgeting and for understanding scope. It does not discuss the volume-floor mechanics that would change results.

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

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

Two short sentences, zero filler. The usage cue and aggregation modes come first, and the cost constraint is placed last where it reads as a caveat.

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?

An output schema exists, so return values needn't be explained, and the schema covers defaults for league, season, min_games and season_type. What is missing for a 6-parameter ranking tool is routing against neighbors like get_team_stats and get_player_games, plus any note on whether limit truncates or errors.

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 83% and the schema already documents season, league, min_games default and season_type. The description's mention of 'shooting percentages with a volume floor' hints at how the pct stats are constrained and at what min_games governs, but it maps nothing to actual parameter names, so it stays at the 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+resource: season statistical leaders computed from every box score, and names the three aggregation modes (per game, shooting percentages with a volume floor, totals). It is clearly distinct from get_team_stats or get_standings by implication, though it never names those siblings 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?

'Use for...' gives an implied usage condition, which is better than nothing. But there is no when-not guidance (e.g., use get_player_games for a single player's logs, get_standings for team records) and no alternative is named despite many adjacent siblings in the catalog.

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, and the description layers on non-obvious behavior: a 10-credit cost, snapshot cadence (daily, plus hourly for games within four days), and a compliance boundary on how prices may be used. Cost disclosure and capture cadence are things an agent cannot learn from annotations or schema.

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

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

Two sentences, purpose front-loaded, and every clause in the long second sentence carries distinct information: capture cadence, credit cost, and the market-information constraint. Nothing is restated from the title or 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?

With an output schema present, return values need no explanation, and the description still covers the things schema cannot: pre-game-only scope, credit cost, snapshot frequency, and the prohibition on stake or bet advice. An agent has everything needed to call it correctly and interpret the result within its constraints.

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 to the snapshot concept behind all_snapshots by explaining what a snapshot is and how often one exists. It does not add anything about game_id, league defaults, or the single-book provider filter beyond what the schema already says.

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 — pre-game snapshots of each sportsbook's moneyline, spread and total — so the agent knows this returns historical line movement rather than current prices. It is distinguishable in substance from get_odds, but it never names that sibling, so the differentiation is inferred from the word 'moved' 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?

The opening 'Use to see how a game's line moved before tip-off' gives a clear triggering condition, and the final sentence sets hard exclusions on what the agent must not do with the returned prices. What is missing is an explicit alternative for current lines (get_odds) or a statement of when this tool is the wrong choice.

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

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

Annotations only declare readOnly/idempotent/non-destructive; the description adds real behavioral context beyond that: per-call credit costs (5 vs 10), the historical nuance about what each book reports pre- vs post-July 2020, and the calculation against the median close. The explicit policy boundary (never compute stake, payout or profit, never recommend a bet) is a non-obvious constraint an agent could easily violate.

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 is front-loaded in the opening clause and the parameter guidance follows logically. The single paragraph is dense and a bit run-on, but nearly every clause carries either scope, cost or policy information that 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?

Output schema exists so return values need no explanation, all three parameters are schema-documented, and the description still covers cost, historical caveats and usage policy. An agent has everything needed to select and 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 coverage is 100%, so the baseline is 3, but the description adds value the schema does not: it discloses that game_id and date are alternative access paths with different credit costs. The league parameter's default and enum are left to 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 resource (betting lines) and enumerates exactly what is returned: each sportsbook's moneyline, spread and total, plus implied probabilities and cover/over outcomes. It also scopes the historical coverage (opening/closing per book from July 2020, final pregame line before), which no sibling 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?

Gives concrete routing between the two modes of use: pass game_id for one game or date for a day's games, with credit cost attached to each. It does not explicitly distinguish itself from siblings like get_line_movement or get_player_props, so the agent must infer that this is the single-game/day snapshot 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 establish that this is a read-only, idempotent, non-destructive, closed-world operation. The description adds useful behavioral context by disclosing the 5-credit cost and clarifying that regular-season and postseason splits are returned separately; it does not cover error behavior or response shape, but those are less critical given the output schema.

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

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

The description is two compact sentences with no wasted wording. The main capability is front-loaded, followed immediately by the sibling-tool routing and cost.

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

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

Given the annotations cover safety and idempotency, the output schema covers return values, and the input schema documents both parameters, the description supplies exactly the missing context: what data are included, how postseason splits are handled, when to use an alternative, and the credit cost.

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 player_id and league are already fully documented in the schema. The description does not add syntax or format detail about either parameter, so the baseline of 3 applies.

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

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

The description names the specific resource (player) and the exact data returned: profile, per-season averages, shooting splits separated by regular season/postseason, and last 10 games. It also explicitly distinguishes this tool from get_player_games for game-level data, so an agent can select it 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 usage guidance with 'Use for...' and explicitly routes game-by-game requests to get_player_games. The condition for the alternative is stated directly, leaving little ambiguity about when to choose this 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 and closed-world, so the safety profile is covered. The description adds genuinely new behavioral facts: results are ordered 'newest first', scope is optionally one season, and the call 'Costs 5 credits' — a cost signal not present in any structured field. Pagination behavior (limit/offset) is not described, but that is partially covered by schema defaults.

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 use case front-loaded, then returned content, ordering, scope and cost. Nothing is redundant or buried.

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 an output schema present and rich annotations, the description only needs to supply scope, ordering and cost — all of which it does. The remaining gap is that pagination (limit/offset) and season_type filtering are never mentioned, which matters for a tool that can return up to 200 rows.

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 67%, with offset and season_type carrying no schema descriptions at all. The description's only parameter-relevant statement ('optionally one season') restates what the season field already documents, so it does not compensate for the undocumented parameters. Baseline 3 is appropriate for this coverage level.

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 ('a player's game log') and details the returned content ('every game's box-score line with opponent and result'), which implicitly separates it from get_game (single game) and get_plays. It stops short of naming any sibling outright, so the differentiation is inferable rather than 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?

The leading 'Use for a player's game log' establishes a clear context for invocation, and 'optionally one season' clarifies the common filtering scenario. There are no exclusions or pointers to alternatives such as get_game or get_player, leaving the agent to infer when this is the wrong pick.

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 well past the readOnly/idempotent annotations: it discloses the credit cost (10 before start, 20 after, with an account-age exception), the estimate_only escape hatch, that closing is the default snapshot, the capture-timing semantics of each row, and the sparse-archive caveat that opening and closing are usually identical. It also states a hard use policy (no stakes, payouts, recommendations or book referrals).

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 access modes, cost and return semantics, and every clause is load-bearing for an agent building a query. It is a dense single block, though, and the opening-vs-closing capture explanation slightly restates what snapshot_type already says.

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, cost-bearing data tool with an output schema, it covers everything needed to call correctly: coverage windows, cost, snapshot defaults, row timing fields, and the backtest filter. The output schema carries the row shape, so no return-format explanation is owed.

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 baseline is 3, but the description adds real semantics the schema only hints at: game_id returns every player's props for that game, player_id+from_date/to_date spans games with a 100-row cap, and closing/opening defaults are explained alongside the row-level capture fields. It leaves bookmaker-key values and league defaults largely to 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?

Opens with a specific verb+resource ('player prop lines by sportsbook') and enumerates the exact markets, leagues, date coverage and books, which cleanly separates it from get_odds, get_prop_history and get_line_movement.

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 two explicit access patterns — game_id for a whole game versus player_id with from_date/to_date (capped at 100) for one player — plus a concrete instruction to filter minutes_before_scheduled_start > 0 for a strict pre-game backtest and to use estimate_only for unpriced calls. It never names a sibling tool as the alternative for a competing need, 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 readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds genuinely non-structured facts: data only goes back to 2018 for the score/win-probability fields, league defaults to NBA, and each call costs 10 credits. It stops short of describing pagination behavior or how scoring fields behave for pre-2018 seasons beyond the parenthetical.

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

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

Two sentences, front-loaded with the use case, then the payload, then filters, then league defaults and cost. Every clause carries distinct information with no restatement of the tool name or annotations. Dense but readable given 13 parameters.

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 an output schema present, return values need not be explained, and the description covers the remaining unknowns: temporal coverage, league switching, cost, and default season. Pagination via offset/limit and the meaning of season_type are left entirely to the schema and are the only meaningful omissions for a 13-parameter 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 77%, so several fields (offset, period, season_type) carry no description. The prose compensates by explaining the league switch and its default ('Pass league for the WNBA (wnba) or college (ncaam, ncaaw); default NBA') and by grouping the filter parameters into a readable set of choices. It does not clarify the offset/limit paging pair, leaving one gap against the remaining 23%.

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 up front ('Use for play-by-play') and defines scope precisely: every event of a game, or a player's/team's plays across a season. The listed payload (shot location in feet, zone, expected points, score and home win probability after each play) makes it unmistakably a play-level feed. It never names the nearest sibling, get_shot_chart, so an agent must infer the boundary between an aggregated chart and event-level data.

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

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

Gives explicit selection criteria: pass game_id for one game, player_id plus season for a player, team for a team, and a full set of filter conditions (shots/makes/misses, zone, period, clutch). This is a clear usage context. However, it offers no exclusions or named alternatives (get_shot_chart, get_player_games, get_game) for the cases where this tool is the wrong choice.

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

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

Goes well beyond the readOnly/idempotent annotations by disclosing the credit cost model (10 credits per 25 games, minimum 10, legacy pricing), the 200-game cap per call, and a compliance constraint against computing stakes or recommending bets. These are exactly the traits an agent cannot infer from structured fields.

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 use case, then payload, then cost, then compliance — a sensible priority order with no filler. The sentences are long and dense (the cost clause and the compliance clause run together), costing some readability.

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

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

For an 8-parameter, credit-metered, paginated tool, the description covers what it returns, the per-call ceiling, cost behavior, the free-estimate escape hatch, and safety constraints. An output schema exists and pagination continuation is documented in the schema, so nothing essential 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 baseline is 3; the description adds real meaning by explaining that bookmaker substitutes one book's close for the cross-book median and that the opening line equals the close where only a single capture exists. Market enum semantics are restated rather than expanded.

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 ('see how a player did against his prop line over time') and enumerates exactly what a row contains: closing line, opening line, prices, actual box-score result, over rate. This is clearly distinguished from sibling get_player_props (current lines) and get_player_games (raw game logs).

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?

Opens with an explicit 'Use to...' context and gives a concrete decision rule for the estimate_only flag ('get the price without being charged'). It does not explicitly name when to prefer get_player_props or get_player_games instead, so routing is implied rather than stated.

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

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

Annotations already establish the safe, idempotent, closed-world read profile, so the description's job is to add what they can't. It does: it discloses a concrete cost ('Costs 2 credits') and the data provenance (Elo from every final game), both of which materially affect whether an agent should call this repeatedly. It omits any note on ranking scope (all teams vs. a limit).

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

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

A single sentence that front-loads the resource and method, then appends the temporal scope and cost. Every clause carries information; nothing is redundant or buried.

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?

An output schema exists, so return shape need not be described, and annotations cover safety. The description supplies the pieces structured data can't: provenance, cost, and time basis. Minor gaps remain around ranking extent and whether zero-parameter calls are the common path, but nothing critical 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 both parameters are already documented, including the league enum and the season default. The description's 'as of the end of a season or today' mildly reinforces that season is an end-year with a current-date default, 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?

The description names a specific resource (team power ratings) and discloses the method behind it (Elo computed from every final game in the dataset), which implicitly separates it from official-record tools like get_standings. It stops short of explicitly naming a sibling or stating a distinguishing condition, so it lands just under 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?

'Use for our team power ratings ... as of the end of a season or today' gives a usage context and a temporal scope, but offers no when-not guidance and never mentions alternatives such as get_standings or get_team_stats that an agent could easily confuse this with. Usage is implied rather than directed.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds important context beyond annotations: it costs 2 credits, returns median lines rather than all book lines, and includes explicit policy constraints on how pricing information may be used. These details materially affect invocation and downstream handling.

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 primary use case and scope, then names the sibling alternative, cost, and usage constraints. Every sentence earns its place, and there is no redundant repetition of structured annotations.

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

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

Given that annotations cover safety traits, the schema fully documents parameters, and an output schema exists, the description supplies the remaining agent-critical context: cost, date scope, median-line behavior, sibling routing, and policy restrictions. Nothing important for correct selection or 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 the schema already documents days, team, and league. The description reinforces the days range and default but does not add meaning for team or league beyond what the schema provides. A baseline 3 is appropriate because the schema carries parameter semantics.

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

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

The description clearly states the resource: upcoming games over a 1-30 day window with median sportsbook lines for spread, total, and moneylines. It also distinguishes the tool from get_odds by saying get_odds is for every book's line. An agent can identify this as the schedule-plus-median-market tool 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 usage conditions: use for upcoming games, default 7 days, range 1-30 days. It names the alternative get_odds when per-book lines are needed. It also sets clear behavioral boundaries around not calculating stakes, payouts, profits, recommending bets, or directing users to sportsbooks.

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, so the safety profile is covered. The description adds two things annotations cannot: a 10-credit cost and the 3,000-shot cap on include_shots. It does not say what scope results from calling with no arguments (all params optional), which would have made it 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?

Two sentences, no padding. The output content and zone list come first, the conditional parameter second, the cost last. Every clause conveys something an agent needs.

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

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

An output schema exists so return shape needn't be spelled out, yet the description usefully names the metrics and the costly optional flag. With 8 optional parameters and zero required, the one real gap is that it never says whether an empty call is valid or what it defaults to.

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 63%, and the schema already documents team, league, season, opponent and include_shots. The description restates zone grouping and the include_shots effect but adds no syntax guidance for game_id, player_id or season_type, the undocumented portion. 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 resource and output shape: per-zone attempts, makes, percentage, points per shot and expected points per shot, enumerated zones, and four scoping modes (player, team, team's opponents, one game). An agent knows exactly what it will get back. It never names a sibling or clarifies how it differs from e.g. get_team_stats, which is the only missing element.

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?

'Use for a shot profile' is an explicit use cue, and the description enumerates the valid scoping combinations (player / team / opponent / game). It also tells when to flip include_shots (only when you need shot locations for a chart). No when-not-to-use or explicit alternative tool is given, 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 readOnly, idempotent, non-destructive, and closed-world behavior. The description adds important non-schema context: standings are computed only from final games, the exact metrics included, and the tool costs 2 credits.

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 compact sentences with zero filler: the primary purpose and scope come first, and the credit cost is tacked on efficiently.

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

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

An output schema exists, annotations cover safety profile, and the description supplies the remaining key context: data source ('every final game'), included metrics, and cost. Nothing essential 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 league and season defaults are already fully documented. The description mentions 'a season's' standings but adds no syntax or format detail beyond the schema.

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

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

States a specific resource (regular-season standings) and enumerates the exact record categories returned, so an agent can distinguish it from siblings like get_team_stats or get_ratings 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?

Opens with 'Use for a season's regular-season standings,' giving clear context for selection. It does not name alternatives or exclusions, but the scope is explicit enough for most selection decisions.

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 safety (read-only, idempotent, non-destructive, closed-world), so the description's added details are what matter: it aggregates 'from every box score' and states the cost of 5 credits. Those are useful behavioral facts beyond the annotations, though it could say more about defaults or output 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 definition is a single front-loaded sentence: purpose first, then the metric list, then cost. Every clause earns its place by clarifying what gets returned or what it costs.

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?

Output schema and annotations cover return shape and safety, and the description adds cost and aggregation context. However, for a 4-parameter tool with only 75% schema coverage, the missing season_type explanation and lack of sibling routing leave gaps an agent could stumble on.

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 75%, so the schema documents team, league, and season, but season_type has no description. The tool description adds no parameter-level meaning, such as how season_type interacts with season or what values are valid beyond the enum.

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 pairing: team efficiency stats for a season, with concrete metrics (pace, ratings, four factors, three-point rate). It is clear what the tool returns, but it does not distinguish itself from potentially overlapping siblings such as get_ratings or get_standings.

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?

'Use for team efficiency for a season' implies the use case, but there is no explicit guidance on when to choose this over get_ratings, get_standings, or get_player_games. No exclusions or alternatives are 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=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds information annotations cannot convey: default sort order ('newest first'), that scores are included, and the cost ('Costs 2 credits'), which matters for a metered API. It stops short of describing pagination behavior beyond what the schema's 'use next_offset' note implies.

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 with the primary routing information front-loaded and the exclusion rules second. Minor economy: 'Use to list' is slightly padded versus a direct declarative, but nothing is wasted.

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?

An output schema exists, so return values need not be explained, and the description still flags ordering and credit cost. For a 10-parameter, all-optional filter tool the guidance is sufficient to call it correctly, though pagination behavior and the effect of combining date with from/to are left to 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 90% and the schema documents date formats, enums, default limit and the season-year convention, so the schema carries the burden. The description names the principal filter dimensions but adds no format or interaction detail (e.g. how date/from/to combine when passed together) beyond what is already structured.

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 ('list games with scores') plus the filter axes (season, date, date range, team) and the ordering ('newest first'). It also names the two siblings it is not, so an agent can distinguish it from get_schedule and get_game 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?

Explicit when-to-use-alternative routing: 'For upcoming games with lines use get_schedule; for one game's box score use get_game.' This maps each competing need to the correct tool, leaving nothing to inference.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavioral context not in any structured field: the cost ('Costs 1 credit') and the default season ('the latest'), both of which affect how an agent budgets and interprets a call. It stops short of describing result shape, but an output schema exists to carry that.

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

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

Three short sentences, each carrying a distinct payload: purpose, prerequisite routing, league branching, and cost. The purpose is front-loaded and there is no filler or restatement of the title.

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

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

With only two optional parameters, full schema coverage, and an output schema handling return values, the description covers everything an agent needs: why to call it, how to select league, what season defaults to, and what it costs.

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; the description earns above that by adding the season default ('the latest'), which the schema does not state, and by mapping the league enum values to real-world meaning (WNBA vs college vs NBA default) rather than just repeating the enum list.

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 ('find team ids and abbreviations') plus the scoping dimension ('for a season'). The sentence 'Every other tool takes a team as an id or abbreviation' positions it unambiguously against all 17 siblings as the prerequisite lookup tool.

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?

Tells the agent exactly when to reach for it (before any team-scoped tool, since all others need an id or abbreviation) and how to branch by league: wnba, ncaam, ncaaw, with nba as default. No alternative tool competes for this job, so no exclusion clause is needed.

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). The description adds genuinely new behavior: results ordered most-recent-first, partial-name matching, the default league, and a cost of 1 credit — the credit cost in particular is not derivable from any structured field.

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 primary use case, followed by the parameter guidance and the cost note. There is no filler and nothing an agent must read past to act.

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 3-parameter lookup with an output schema, the description covers purpose, matching behavior, ordering, league options, and cost. Minor gaps remain: it doesn't say what happens when the name is ambiguous or how many matches return against 'limit'.

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 67%; the description adds meaning beyond the schema by clarifying that partial names work and that league switches between WNBA and college vs the NBA default. The 'limit' parameter is documented nowhere, which keeps this from a 5, though its min/max make it largely self-explanatory.

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 ('find a player's id by name') plus the matching semantics (partial names) and ordering, which distinguishes it from a detail-fetch sibling like get_player. It does not name get_player explicitly as the follow-up tool, so the id-lookup vs full-profile split is implied 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?

'Use to find a player's id by name' and 'Pass league for the WNBA or college' give clear operating context, including which cases require the league parameter. No explicit exclusions or named alternatives (e.g. when to use get_player instead), 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.