infersports

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

Beyond the readOnlyHint annotation, the description discloses useful behavior: verbosity modes, what 'terse' drops (the per-book books array), and that analytics are computed in decimal regardless of display format. It also clarifies the source of fair odds ('from the sharpest (lowest-margin) book'), which is meaningful behavioral detail.

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 well-structured: a one-sentence purpose followed by a scannable Args list. Every sentence adds value, and the most important information about the return payload and verbosity trade-off is included without 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?

Despite no output schema, the description states the main return components and parameter effects. It covers all five parameters, gives defaults context, and explains how the 'terse' mode changes the response. An agent has enough information to call the tool correctly and interpret the result.

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

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

With 0% schema description coverage, the description fully compensates by documenting every parameter: event_id with an example, market_type with allowed values, period options, format semantics, and verbosity behavior including payload impact. This is exactly what the schema itself lacks.

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: 'Compare one market across all bookmakers for a match.' It then enumerates concrete outputs such as consensus line, best price per outcome, overround, and de-vigged fair odds, making it clearly distinct from sibling tools like compare_prob or get_match_odds.

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 makes the intended scenario clear: use this tool when you need a cross-bookmaker comparison of a single market for a given match. It does not explicitly name alternatives or state when not to use it, but the purpose is specific enough to guide selection among similar siblings.

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

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

Despite readOnlyHint already conveying non-mutation, the description goes well beyond annotations: it discloses the de-vig computation, output fields (edge, ROI, verdict), status values ambiguous and no_line, and market caveats like 90-minute vs extra-time. No contradiction with the annotations.

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

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

The description is long but deliberately structured: purpose first, then Args, then caveats. It front-loads the core action and detection-only nature, and every paragraph adds operational information rather than repeating the schema or annotations.

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

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

With 8 parameters, no output schema, and 0% schema description coverage, this context is hard to make complete. The description documents all params, specifies valid values and defaults, lists computed fields, and warns about ambiguity, no_line, and market-shape edge cases.

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

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

The input schema has 0% description coverage, so the description carries the full burden. The Args section explains every parameter with valid values, defaults, and examples, fully compensating for the bare 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 ('Judge ... against our sharp fair line') and a resource (external probability vs sharp fair line), and adds the unambiguous scope 'ONE call'. The detection-only clarification further separates it from scoring or betting tools in the sibling list.

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

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

Gives clear context: use it when you have an external prediction-market probability and need the fair-line gap, and it explicitly says it never sizes stakes or picks. It stops short of naming sibling alternatives such as compare_lines or score_prob, so it earns a 4 rather than 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 indicate readOnlyHint=true, so the description adds value by specifying the splitting logic and the constraint that the line must be a multiple of 0.25. This goes beyond the annotation and provides practical behavioral detail, though it doesn't cover edge cases or error 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 two sentences, front-loaded with the purpose, and provides a concrete example. Every sentence is necessary and there is no redundant information.

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

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

For a simple read-only tool with a single parameter and no output schema, the description covers the core behavior, the input constraint, and the output nature (states conditions). Nothing essential is missing for an agent to call it correctly.

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

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

The schema only defines line as a number with no description, so schema coverage is 0%. The description compensates by explaining the requirement that line be a multiple of 0.25 and giving an example of the splitting process. This adds critical meaning that the schema lacks.

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

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

The description clearly states the tool explains an Asian handicap line and details exactly what it does: splitting quarter lines and listing win/loss conditions. This distinguishes it from sibling tools like compare_lines or find_arbitrage, which have different objectives.

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

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

The description implies the tool is for understanding a line rather than comparing or searching, which differentiates it from siblings. However, it does not explicitly state when not to use it or mention alternative tools, but the purpose is unambiguous enough for most agents.

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

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

Beyond the readOnlyHint annotation, the description adds rich behavioral context: it explains the arbitrage detection algorithm (inverse prices sum < 1), the requirement of ≥2 distinct books, that it reports margin % and leg-owning books, and the ambiguous-query behavior with 'status' and 'ask_user'. This goes well beyond annotation coverage.

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 longer than minimal but every sentence earns its place: definition, algorithm, detection disclaimer, and parameter list. It is front-loaded with the core purpose and the parameter list is logically ordered. Slight redundancy in mentioning read-only twice could be trimmed, but it remains efficient.

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

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

For a tool with 7 parameters, no output schema, and a nontrivial algorithm, the description covers the essential invocation details and expected output (margin % and book per leg). It also handles the ambiguous-query edge case. It does not enumerate all possible statuses or error responses, but that is a minor gap given the complexity; a 4 reflects solid completeness without being exhaustive.

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

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

With schema description coverage at 0%, the description fully compensates by explaining every parameter: query with example, markets with allowed values, period values, min_margin_pct semantics, format options, sport filter, and date for disambiguation. No parameter is left unexplained, so an agent can compose arguments correctly without schema hints.

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: 'Find cross-book arbitrage in a fixture — a guaranteed-profit price split — in ONE call.' It clearly distinguishes from sibling tools like find_value (value betting) and compare_lines (line comparison) by stating the single-call resolution and detection-only scope, making the tool's identity unmistakable.

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 states when-not: 'DETECTION ONLY: no stake sizing, no bet links — InferSports is read-only,' and instructs not to guess on ambiguous queries. However, it does not name specific alternative tools (e.g., find_value for stake sizing) or provide a condition for choosing this over a sibling, so it stops short of a full 5.

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

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

Annotations declare readOnlyHint=true, and the description adds useful behavioral context: it returns a confidence score, alternatives, a decision block with safe_to_proceed and next_action, and the live clock format. It doesn't contradict annotations.

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

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

The description is well-structured with an Args section and a Returns section, front-loading the core purpose. It is slightly verbose in the returns paragraph but every sentence adds useful information.

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

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

Given the tool's moderate complexity (3 params, no output schema), the description covers the query format, filters, return fields, and downstream usage. It doesn't explain edge cases like ambiguous matches in detail, but the decision block mention covers ambiguity handling.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains query with examples, sport as an optional filter with allowed values, and date as a UTC disambiguator. This compensates well for the lack of 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 states a specific verb ('Find') and resource ('football/basketball fixture by natural-language name'), and distinguishes it from siblings by emphasizing natural-language lookup and returning a best-matching event. It clearly differentiates from tools like list_events or list_today_matches.

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 concrete usage context: natural-language query, optional sport/date filters, and explicitly says to use the returned event_id with get_match_odds / compare_lines. It doesn't explicitly state when NOT to use it versus siblings, but the context is clear enough.

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

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

Beyond the readOnlyHint annotation, the description discloses several key behaviors: it is detection-only and 'does NOT size stakes or link out to bet'; on ambiguous queries it returns 'status'=>'ambiguous' with 'ask_user' and instructs 'do not guess'; it depends on the sharp book and on the Free tier flags fair as approximate. These details significantly exceed the annotation and help the agent understand edge cases.

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

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

The description is well-structured: a one-sentence front-loaded purpose, a concise process explanation, a highlighted 'DETECTION ONLY' note, a clear Args list, and a final behavioral note. It is somewhat long but every sentence earns its place; no redundancy. The top score is held back only by minor verbosity in the process explanation that could be tightened.

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?

Despite lacking an output schema, the description covers all necessary call information: how the tool works, all parameters with defaults, the ambiguous-query response, the Free tier constraint, and the detection-only scope. There is nothing an agent needs to invoke it correctly that is missing. It is complete for its complexity.

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

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

The schema has zero descriptions, so the description carries the full burden. It explains each of the 7 parameters in the Args block: query as natural-language fixture, markets with allowed values, period with allowed values, min_edge_pct with meaning, format with options, sport with options, and date for disambiguation. This adds substantial meaning beyond the bare schema types and defaults.

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+resource: 'Find +EV value bets in a fixture' and elaborates the exact detection mechanism ('de-vigs the sharp book... flags every outcome whose best available price across books exceeds that fair price'). It also clearly distinguishes its scope from betting actions via 'DETECTION ONLY'. This is unambiguous and differentiates it from siblings like find_arbitrage or get_sharp_line.

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

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

The description gives clear context on when to use it (to find value bets in one call) and adds a caution ('DETECTION ONLY' – not for sizing stakes). However, it does not explicitly name alternative tools or state 'use this instead of X'. The 'in ONE call' phrasing implies comprehensiveness, but no explicit when-not guidance is provided, so it doesn't fully reach the top score.

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

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

The readOnlyHint annotation is present, and the description does not contradict it. The description adds behavioral detail beyond the annotation by specifying default values for period and format, and by explaining that markets and bookmakers are optional filters. It does not cover rate limits or auth, but the read-only nature is clear. Overall, it adds useful context without overstepping.

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 compact single sentence stating the core purpose, followed by a clearly structured Args list. Each parameter is documented in one line with no redundancy. The main purpose is front-loaded, and the optional filters are grouped logically. There is no wasted verbiage.

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?

Considering the tool has 5 parameters, no output schema, and no nested objects, the description covers all parameters with their defaults, allowed values, and example formats. It provides enough context for an agent to call the tool correctly without needing additional documentation. The absence of an output schema means the description need not describe return values, keeping it complete for its complexity.

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

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

Schema description coverage is 0%, so the description is the sole documentation for parameters. It fully explains each parameter: event_id (from find_match/list_today_matches, with example format), markets (optional filter with allowed values), bookmakers (optional filter with keys), period (optional, full_time or half_time, default both), and format (odds format options). This completely compensates for the schema's lack of 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 starts with 'Get all current odds for a match across bookmakers,' which names a specific verb, resource (match odds), and scope (across bookmakers). It distinguishes itself from siblings like get_opening_line and get_sharp_line by emphasizing 'current odds,' making its purpose unambiguous.

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 mentions that event_id comes from 'find_match / list_today_matches,' providing clear sourcing guidance. It also clarifies which parameters are optional filters (markets, bookmakers, period, format). However, it does not explicitly state when to prefer this tool over get_opening_line or get_sharp_line, though 'current odds' implies it. This is a minor gap preventing 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?

Beyond the readOnlyHint annotation, the description discloses critical behaviors: ambiguous queries return status 'ambiguous' with an ask_user prompt, and books/lines with no opening are omitted on a best-effort basis. It also explains the line vs current_line semantics for totals/AH, which is essential for correct interpretation. No contradictions with annotations.

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

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

The description is front-loaded with a concise purpose statement, then structured with a clear Args list and additional notes on ambiguity and best-effort behavior. Every sentence adds value; there is no fluff or redundancy. The length is justified by the tool's complexity.

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

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

The description covers all parameters and explains key return behaviors (status, ask_user, line vs current_line, omission), but since there is no output schema, it does not fully specify the response structure. However, it provides enough for an agent to know what to expect and how to handle ambiguous results, making it nearly complete for a tool of this complexity.

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

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

With 0% schema description coverage, the description fully compensates by explaining every parameter in the Args section, including examples (query: 'Real Madrid vs Barcelona'), allowed values (markets: '1x2', 'asian_handicap', 'totals'), and format options. This adds substantial meaning beyond the raw schema.

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

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

The description states a specific verb (Get) and resource (opening odds for a fixture) paired with the current price, and explicitly distinguishes its purpose from siblings like get_match_odds (current odds) and get_sharp_line. It also explains how to read movement, making the tool's unique value immediately clear.

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

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

The description gives clear context on when to use this tool—when you need to compare opening vs current odds to read movement—and explains the interpretation for different market types. However, it does not explicitly name alternative tools or state when not to use it, relying on the reader to infer from the context.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral context: it returns cached data only (30-day window), status field indicates found/not_found, and it excludes odds. However, it doesn't disclose details like whether the result is final only after match completion or what happens for live matches, but the cache limitation is a meaningful addition.

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: the first sentence states the core purpose, followed by return fields, status semantics, and parameter guidance. Every sentence earns its place, and the Args section is directly useful.

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

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

For a simple one-parameter read-only tool, the description covers the key aspects: what it returns, the cache limitation, the status field, and the parameter source. It doesn't describe the exact response structure, but there is no output schema and the description lists the main fields. Minor gap: it doesn't specify whether the match must be finished or what happens if the event_id is invalid, but overall it's complete enough 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 0%, so the description must compensate. It explains event_id is the event id from find_match or list_results, and gives an example format 'evt_…'. This adds meaning beyond the bare schema property title 'Event Id'.

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

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

The description clearly states the tool retrieves the cached final result for one finished match by event id, and explicitly distinguishes it from results-only data (no odds). It names the resource (cached final result) and the key identifier (event id), making it easy to differentiate from siblings like get_match_odds or list_results.

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

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

The description provides clear context: use it for a single finished match's final result, and it notes the 30-day cache limitation. It doesn't explicitly name alternatives or say when not to use it, but the context is sufficient for an agent to select it appropriately among siblings.

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

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

Annotations only provide readOnlyHint, but the description adds substantial behavioral context: it explains the decision block (safe_to_proceed / ask_user / next_action), what happens on ambiguity, and how verbosity='terse' changes the books array output. It also clarifies output structure (summary/comparison) beyond the annotation, with no contradiction.

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

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

The description is front-loaded with the one-line purpose, then organized into parameter details and behavioral notes. It is longer than average, but that length is justified given 7 parameters with zero schema coverage and the need to explain disambiguation and verbosity behavior. No sentence is pure filler.

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

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

For a 7-parameter tool with no output schema, this description is remarkably complete: it tells the agent what inputs to use, what outputs to expect, how to handle ambiguity, and which block to branch on. It even accounts for the output size optimization of 'terse'. The one thing not covered (e.g., error status when no fixture is found) is minor given the detail present.

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

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

Schema description coverage is 0%, so the description bears full responsibility for parameter semantics. It documents all 7 parameters with default values, allowed values (market_type, period, format, verbosity), examples for query, and the practical effect of verbosity. This is strong compensation for an otherwise empty schema.

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

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

The description names a specific verb and resource: 'Answer an odds question about a fixture in ONE call' and enumerates exactly what it computes (consensus line, best price, de-vigged fair odds, summary, comparison). It also distinguishes itself from the sibling chain find_match → compare_lines, so an agent can separate it from related 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?

It explicitly prescribes when to use this tool: 'Prefer this over chaining find_match → compare_lines.' It also gives a clear conditional behavior for ambiguous queries: 'do not assume a match; ask the user or re-call with a more specific query.' This is concrete, actionable when/when-not guidance.

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

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

Annotations declare readOnlyHint=true, which is aligned (no contradiction). The description adds that the output is filtered by tier and includes a note on coverage, and explicitly mentions free tier excludes Pinnacle. This goes beyond the annotation by specifying the conditional nature of the result but does not describe return format or pagination, which is minor given no parameters.

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

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

Two concise sentences with all necessary info. Front-loaded with the main purpose, then details output fields and usage guidance. No fluff; every word earns its place.

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

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

Given zero parameters, readOnly annotation, and no output schema, the description fully covers what an agent needs: what it returns, how to use it, and limitations. It even specifies how to use the output with sibling tools. Nothing 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?

Tool has zero parameters, so schema is empty and coverage is 100% (trivially). The description explains the output structure (key, name, class, note) and its purpose, which adds meaning beyond the empty schema. Since there are no parameters to document, this is solid.

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 specific verb 'list' and resource 'bookmakers', and clearly distinguishes the output: a curated catalogue with key, name, class, and tier note. It differentiates from siblings by explicitly naming the filter usage and mentioning free tier exclusion of the sharp book. This is unambiguous and uniquely identifies the tool's function.

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

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

Provides explicit guidance on when to use: to retrieve available bookmakers for a given tier. It also tells the agent to use returned 'key' values in 'bookmakers' filter of get_match_odds / compare_lines, which is a direct alternative usage. It implicitly excludes other siblings by focusing on catalogue listing rather than odds or probabilities. The free tier note adds a condition for expected output. No gaps.

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

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

Beyond the readOnlyHint annotation, the description discloses timezone handling (day boundaries computed in the given zone, local time added), the truncation/limit behavior, and the inclusive date range with a 31-day cap. This enriches the agent's mental model of side effects and edge cases without contradicting annotations.

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

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

The description is long but every sentence earns its place: purpose, sibling contrast, timezone nuance, truncation, and a clean Args list. The main intent is front-loaded, and the structure guides the reader from general to specific. No filler.

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

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

For a tool with 7 parameters, no output schema, and no enums, this description is remarkably complete. It covers all parameter semantics, timezone behavior, range constraints, filtering strategy, and notes the truncation flag. The only minor omission is a full field list of returned fixtures, but the mention of scheduled_at/scheduled_at_local gives sufficient shape for a listing tool.

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

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

Schema description coverage is 0%, so the description carries the full burden. It explains every parameter with format examples, constraints (e.g., date_to max 31 days, limit 1–200, default 50), and semantic meaning (e.g., timezone for day boundaries, fuzzy league matching). This far exceeds what the bare schema provides.

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

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

The description states a specific verb ('List') and resource ('fixtures for a calendar day or range'), and explicitly contrasts with sibling list_today_matches to distinguish scope. It leaves no ambiguity about what the tool does or how it differs from the nearest 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?

The description provides explicit when-to-use guidance: it names list_today_matches as the alternative for live/today events, explains when to use date_to to cover a tournament window in one call, and advises narrowing with filters rather than paging. This is actionable routing information.

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

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

Beyond readOnlyHint=true, the description discloses the 30-day retention window, persistence across restarts, entry fields (final score, red cards, finished time), absence of odds, and most-recent-first ordering. No contradiction with annotations.

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

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

The description is compact and front-loaded: one sentence states purpose and scope, one paragraph defines the result content and cache behavior, and the Args block is dense. Only minor redundancy ('most-recent-first' twice) exists.

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

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

For a read-only list tool with four optional parameters and no output schema, this description supplies everything required to call it correctly: filter semantics, ordering, output fields, cache window, and parameter constraints. No gaps that would cause mis-invocation.

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

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

The schema provides no descriptions (0% coverage), but the description documents all four parameters with formats ('YYYY-MM-DD' UTC), matching semantics (case-insensitive substring for team and league), and validation limits for limit (1–200, default 50).

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

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

The description uses a specific verb ('look back') and resource ('finished-match scores from the 30-day results cache'), defines ordering ('most-recent-first') and explicitly contrasts itself with 'live tools', so an agent can distinguish it from the other score/odds 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?

It gives explicit use cases ('what was the score of X?' / 'yesterday's results'), states the cache survives restart unlike live tools, and notes results contain no odds, effectively excluding odds-related queries. It could name specific sibling tools, but the when/when-not guidance is clear.

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

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

Annotations already provide readOnlyHint: true, so the read-only nature is covered. The description adds valuable context: it explains that clock is the live minute verbatim and that clock is null pre-match, and that summary is ready-to-read. This goes beyond annotations and helps the agent interpret the output correctly.

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 well-structured: a one-sentence purpose, a paragraph on what each fixture carries, and a clear Args section. Every sentence earns its place; there is no fluff. The key behavior (today's matches) is front-loaded.

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

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

Given there is no output schema, the description explains the output fields (status, live score, clock, summary) and how timezone affects the summary. It covers all parameters. It doesn't mention pagination or ordering, but for a filterable list tool this is adequate. A minor gap, hence 4.

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 carries the full burden for parameters. It explicitly explains each one: sport, status, league (fuzzy match or external id), limit (with range and default), and timezone (with examples). This adds significant meaning beyond the bare schema.

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

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

States a specific verb and resource: 'List today's (UTC) fixtures' — clearly scoped to today's matches. It distinguishes from siblings like list_results (results) and list_events (broader events) by the 'today' scope, so an agent knows exactly what it 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?

The description implies when to use it (when you need today's fixtures) and offers filters, but it does not explicitly name alternatives like list_events or list_results or state when not to use it. Usage context is clear but no exclusions are given, so it falls at 'implied usage'.

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 readOnlyHint=true, so the description carries the burden of behavioral disclosure. It thoroughly explains output structure (live score, match clock, status, kickoff time, favored team with probability, summary), the 'ambiguous' status with ask_user for ambiguous queries, and best-effort favorite null behavior. This goes well beyond the annotations.

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

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

The description is front-loaded with the primary purpose in the first sentence, then provides examples, detailed parameter explanations, and edge-case notes. Every sentence adds value—no fluff. The structure (purpose → usage → args → caveats) is logical and appropriately sized for a tool with 4 parameters and no output 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 no output schema, the description must explain return values, and it does: live score, match clock, status, kickoff time, favored team with probability, summary, and the ambiguity behavior. It covers all parameters, defaults, and error/edge cases. For a 1-required-param tool, nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 0%, so the description must fully explain each parameter. It does: query (natural-language fixture/team with examples), timezone (IANA names, default UTC), sport (football/basketball), and date (to disambiguate). This adds meaning beyond the bare schema fields, making parameter usage clear.

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: 'Get the basics for a match in ONE call: the score, whether it's live, when it kicks off, and who's favored.' It enumerates concrete outputs and sample user questions, making the tool's purpose unmistakable and distinct from siblings like get_match_odds or find_match which serve different needs.

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

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

The description provides clear context for when to use the tool ('No betting knowledge needed', answers simple questions like 'who's winning?') and explains parameter usage that influences selection (e.g., timezone for local time, sport filter). However, it does not explicitly name alternative tools or state 'use this instead of X' for specific scenarios, so it falls short of the top score.

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

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

Beyond the readOnlyHint annotation, the description discloses meaningful runtime behavior: results are sorted by value/arb signal, truncated to the limit by dropping quiet matches, 'finished is excluded from live', and line movement is intentionally excluded. It also clearly labels itself 'DETECTION ONLY / read-only'.

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 because it must document 10 parameters, but every sentence earns its place. It is front-loaded with purpose and behavior, then flows into an organized parameter list with defaults and allowed values. There is no filler or redundant explanation.

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

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

With no output schema, the description appropriately explains what the tool returns — each fixture with status, live score/clock, and a pre-computed value/arb signal — plus sorting and truncation rules. It also covers all filter semantics, defaults, and the line-movement exclusion, so an agent has enough information to call it correctly without external knowledge.

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

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

The schema has 0% description coverage, so the description carries the full burden for parameters. The Args block documents all 10 parameters with allowed values, defaults, semantic meaning, and examples (e.g., league fuzzy matching, format types, min thresholds, only_signal behavior). This fully compensates for the bare schema.

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

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

The description opens with a specific verb and resource ('Scan today's whole slate in ONE call') and immediately states its value proposition. It names the sibling alternatives it replaces ('batch alternative to looping find_match → get_sharp_line per match'), making it easy to distinguish from related 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?

It explicitly tells the agent when to use this tool — as the batch alternative to looping find_match and get_sharp_line — and when to go elsewhere: line movement is not includedrings and requires get_opening_line. This is direct, actionable routing guidance with named alternatives.

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

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

Annotations provide readOnlyHint=true, and the description adds meaningful behavioral context: it inverts de-vigged 1x2 and totals prices, uses a bivariate-Poisson (Dixon-Coles) model, returns top-K scorelines, fitted goal rates, probability mass coverage, and an 'ah_ev_check' consistency metric. It also clarifies that the asian-handicap fair price is held out of the fit. This goes beyond the annotation by explaining the internal methodology and output semantics. It doesn't mention rate limits or error behavior, but for a read-only analytical tool this is strong.

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 well-structured with a clear first sentence, a detailed methodology paragraph, and a compact Args list. It front-loads the core purpose and scope. It is somewhat long, but every sentence adds value—methodology, output contents, consistency check, and exclusions. The Args section is redundant with the schema but serves as a quick-reference, so it earns a 4 rather than a 5.

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

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

Given the tool's complexity (bivariate-Poisson inversion, multiple outputs, consistency metric), the description covers the key aspects: input format, supported sport, output contents, and the meaning of the consistency check. There is no output schema, so the description's explanation of return values is essential and mostly sufficient. It doesn't specify error cases (e.g., what happens if the fixture isn't found or if markets are missing), but for a read-only analytical tool this is a minor gap.

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

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

Schema description coverage is 0%, so the description carries the full burden. It explains 'query' as a natural-language fixture with examples, 'sport' as an optional filter limited to 'football', 'date' as a UTC disambiguator, and 'top' as the number of scorelines (default 5, max 10). This adds meaning beyond the raw schema, which only shows types and defaults. It doesn't detail the exact format of 'date' beyond 'YYYY-MM-DD' (which it does), so a 4 is appropriate.

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

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

The description states a specific verb ('inverts... into a bivariate-Poisson score grid'), a clear resource (market-implied correct-score probabilities for one football match), and explicitly distinguishes itself from InferSports predictions. It also names the scope constraint ('Football only, one match per call'), which separates it from sibling tools like compare_prob or get_match_odds.

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

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

The description clearly states when to use this tool: for market-implied correct-score probabilities for a single football match. It explicitly says 'never an InferSports prediction' and 'Football only, one match per call,' which helps an agent avoid misuse. However, it doesn't explicitly name sibling alternatives or state when NOT to use it in favor of another tool, so it falls slightly 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.