infersports

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

Annotations indicate readOnlyHint=true, and the description aligns with this. It adds behavioral context: output structure, the 'terse' verbosity option, and that analytics are computed in decimal regardless of format. This goes beyond 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 a one-line summary, bulleted outputs, and an Args block. It could be slightly more concise, but every sentence adds value without redundancy.

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

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

Without an output schema, the description thoroughly explains return values. It covers the terseness option. However, it does not mention prerequisites (e.g., event_id must exist) or edge cases, but overall it is fairly complete for a read-only 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%, but the description compensates by explaining each parameter: event_id, market_type (with examples '1x2', 'asian_handicap', 'totals'), period, format, and verbosity (including what 'terse' does). This adds meaning beyond the schema's 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 explicitly states the tool's purpose: 'Compare one market across all bookmakers for a match.' It then enumerates the specific outputs (lines, consensus, best price, overround, de-vigged odds), clearly distinguishing it from siblings 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 explains what the tool does but does not provide explicit guidance on when to use it versus alternatives (e.g., compare_prob, get_match_odds). There is no 'use this when' or exclusionary advice.

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

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

The description aligns with the annotations' readOnlyHint by stating it never ingests data, sizes stakes, or picks – it only reports the gap. It details the process (resolve, de-vig, report edge/ROI/verdict) and caveats about market types, fully disclosing behavior.

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

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

The description is efficiently structured: a clear one-line summary, followed by detailed behavior, parameter list, and caveats. Each sentence adds value without redundancy, and it is front-loaded with the core purpose.

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

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

Given the tool's complexity (8 params, no output schema), the description provides ample context: it explains the output fields (edge, ROI, verdict), potential statuses (ambiguous, no_line), and market-specific caveats. This allows an agent to understand the full lifecycle of a call.

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?

Despite 0% schema coverage, the description explains all 8 parameters in the 'Args' section with examples, defaults, and nuances (e.g., external_prob pre-net, market_type limitations). 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?

The description explicitly states the tool judges an external probability against a sharp fair line, using verbs like 'judge' and 'compare'. It distinguishes from siblings by emphasizing 'DETECTION ONLY' and contrasting with tools that might ingest or act on data.

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

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

The description provides examples, explains when to use (e.g., for comparing external probabilities), and includes caveats about market types and ambiguous queries. However, it does not explicitly contrast with sibling tools like 'compare_lines' or 'find_value', leaving some ambiguity about which tool to choose in specific scenarios.

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. The description adds disclosure of splitting behavior and condition enumeration, providing value beyond 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?

Three sentences, front-loaded with purpose, then mechanics, then constraint. No wasted words.

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 omits the output format or structure, which is important for an explanatory tool with no output schema. It mentions conditions but not how they are presented.

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 description must compensate. It does so by specifying that 'line' must be a multiple of 0.25 and giving an example, but does not explain the parameter's role in the model.

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, splits it into components, and lists conditions. It is distinct from sibling tools like compare_lines or find_value, which perform different operations.

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

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

The description implies usage for understanding handicap lines and includes a constraint (line must be multiple of 0.25), but does not explicitly state when to use this tool versus siblings or provide exclusions.

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

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

Beyond the readOnlyHint annotation, the description adds that it is read-only ('InferSports is read-only'), detection-only, and explains the arbitrage calculation logic and the requirement for legs from distinct books.

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 efficiently structured with a purpose paragraph, parameter list, and ambiguous query note. It is detailed but every sentence adds value, though slightly lengthy.

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 and lack of output schema, the description explains the return values (margin %, legs, distinct books) and error handling (ambiguous queries), making it complete for agent use.

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

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

Despite 0% schema description coverage, the description provides a detailed Args section for all 7 parameters, including defaults, possible values, and natural language examples, fully compensating for the schema gap.

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

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

The description clearly states it finds cross-book arbitrage in a fixture, using a verb ('find') and specific resource ('arbitrage in a fixture'). It distinguishes from siblings like 'find_value' or 'scan_slate' by focusing solely on guaranteed-profit price splits.

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 notes it is 'DETECTION ONLY' and handles ambiguous queries with an 'ask_user' prompt. It does not explicitly compare to alternatives, but the context makes its use case 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?

Description adds behavioral details beyond readOnlyHint annotation: returns best-matching event with live score, clock, confidence, alternatives, and decision block. 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?

Concise and well-structured: starts with purpose, then Args, then Returns. Every sentence adds value. No extraneous text.

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?

Comprehensive given no output schema: explains all return fields (id, teams, league, kickoff, live score, clock, confidence, alternatives, decision block). Ties usage to sibling tools. Parameter count is low, so description covers all needed context.

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 coverage, description fully compensates by explaining each parameter with examples (e.g., query: 'Man City vs Arsenal', date: 'YYYY-MM-DD', sport: 'football' or 'basketball'). Meaning is clear and actionable.

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?

Description clearly states 'Find a football/basketball fixture' with specific verb 'Find' and resource 'fixture'. It distinguishes from siblings by explaining how to use the returned event_id with get_match_odds and compare_lines, which are listed as sibling tools.

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

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

Provides clear usage context: use returned event_id with specific sibling tools, and notes the decision block indicating safe_to_proceed and next_action. Lacks explicit 'when not to use' but effectively guides the agent.

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

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

Annotations provide readOnlyHint=true, and the description does not contradict that. The description adds significant behavioral context: it resolves the fixture, de-vigs the sharp book, flags outcomes, and describes edge conditions (ambiguous query, Free tier note). This goes well beyond the annotation.

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

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

The description is concise and well-structured: a one-line summary, a paragraph explaining the process, a note on detection-only, and a clear parameter list. Every sentence adds value without redundancy.

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

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

Given no output schema and 7 parameters, the description covers inputs thoroughly and explains output behavior (flaggings, ambiguous status). It lacks explicit return structure details, but overall it is quite complete for a detection 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%, but the description provides detailed explanations for all 7 parameters in the 'Args' section, adding meaning beyond the schema types and titles. For example, 'query: natural-language fixture' and 'min_edge_pct: only report outcomes beating fair by at least this %.'

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 a clear verb and resource: 'Find +EV value bets in a fixture — where a book's price beats the sharp fair line — in ONE call.' It distinguishes from sibling tools like 'find_arbitrage' by specifying value betting vs. arbitrage.

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 explicitly states 'DETECTION ONLY: this surfaces the edge and which book holds it; it does NOT size stakes or link out to bet,' providing clear when-to-use and when-not-to-use guidance. It also warns about ambiguous queries and Free tier limitations. However, it does not explicitly compare to 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 declare readOnlyHint=true, and the description matches this by stating 'Get all current odds.' The description adds parameter details but no additional behavioral traits 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 concise, uses a clear Args structure, and front-loads the purpose. Every sentence adds value without redundancy.

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

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

Given no output schema, the description could mention the return format (e.g., odds data structure). However, it sufficiently covers input parameters and context for usage.

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

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

Schema coverage is 0% (no descriptions in schema), so the description fully compensates by explaining each parameter's purpose, format options (e.g., 'decimal | hk | malay'), and examples (e.g., '["pinnacle", "crown"]').

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 'Get all current odds for a match across bookmakers,' with a specific verb ('Get') and resource ('current odds'). It distinguishes itself from sibling tools like 'get_result' or 'get_opening_line' by focusing on odds retrieval.

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

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

The description provides clear context by referencing 'event id from find_match / list_today_matches' and explaining optional filters. However, it does not explicitly state when not to use this tool or mention 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 declare readOnlyHint=true, which aligns with the read-only nature. Description further details behavior: resolves fixture, returns both quotes, omits markets without opening, and handles ambiguity via status and ask_user.

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 concise opening sentence and a bulleted Args list. While some repetition exists (e.g., 'A market with no opening yet on file is omitted' appears twice), overall it's efficient and 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 7 parameters and no output schema, the description covers return behavior (opening and current quotes, omitted markets, ambiguous status). It includes best-effort note and disambiguation instructions, making it sufficiently complete for effective use.

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

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

With 0% schema description coverage, the description must explain all 7 parameters. It does so clearly: 'query: natural-language fixture', 'markets: optional filter', 'bookmakers: optional filter', 'period', 'format', 'sport', 'date: optional UTC date to disambiguate'. This adds significant meaning 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?

Description clearly states 'Get the opening odds (初盘) for a fixture, paired with the current price, in ONE call.' It specifies the resource (opening odds), verb (get), and unique value (pairing with current price), distinguishing it from siblings like get_sharp_line or compare_lines.

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?

Description explains the core use case: reading movement by comparing opening and current quotes. It also covers edge cases like omitted markets and ambiguous queries. While no explicit 'when not to use' is given, the context is sufficient for an agent to decide.

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 show readOnlyHint=true, and description reinforces read-only behavior. Adds important constraints: only finished matches, 30-day cache, status field for not_found. Provides details beyond annotations without 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?

Description is brief and well-structured, with a clear purpose sentence, return details, and an args section. No redundant information. Could integrate args into prose, but current format is acceptable.

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

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

For a single-param tool with no output schema and readOnly annotations, description covers functionality, return fields, constraints, and parameter source. Lacks explicit return structure, but is sufficient for agent decision-making given sibling context.

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 has 0% description coverage for event_id, but description compensates with format example (evt_…) and source (find_match/list_results). Adds meaningful context 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?

Description clearly states it gets the cached final result for one finished match by event ID, specifying return fields (score, red cards, time, status). Distinguishes from odds tools via 'Results-only — no odds.' Verb+resource is specific and 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?

Explicitly states tool is for finished matches, cached for 30 days, and results-only. Provides source for event_id from find_match/list_results. Could improve by explicitly contrasting with live or odds tools, but given sibling names, context is sufficient.

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 indicate readOnlyHint=true, and the description confirms a single call that resolves and compares. It provides additional behavioral context: handling ambiguity via 'status' and 'ask_user', a 'decision' block for go/no-go, and the response structure (summary, comparison, decision). 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 well-structured with a one-sentence summary followed by bullet-pointed parameters. It is front-loaded with the core purpose. However, the Args section is somewhat verbose; a slightly more concise presentation could improve 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?

Given 7 parameters, no output schema, and sibling tools, the description covers all parameters, explains the response structure (summary, comparison, decision), and addresses edge cases (ambiguity). It lacks explicit details about return values but provides enough context for an AI agent to understand the tool's behavior.

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

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

Schema description coverage is 0%, so the description must compensate. It includes a detailed Args block explaining each parameter (query, market_type, period, format, sport, date, verbosity) with examples and defaults, adding significant value 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?

The description clearly states the tool answers an odds question about a fixture in one call, with natural language input and a worked line output. It specifies key features like resolving the fixture, picking consensus line, best price, and de-vigged fair odds, and distinguishes itself from chaining find_match and compare_lines.

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 explicitly advises to prefer this tool over chaining find_match and compare_lines. It also explains how to handle ambiguous queries (do not assume a match, ask user or re-call). While it gives clear context and a strong alternative, it could mention when not to use it (e.g., for detailed per-book lines rather than a summary).

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, which the description aligns with ('List'). The description adds behavioral details: returns curated catalogue with key, name, class, and a note on tier coverage. This goes beyond the annotation's simple safety hint.

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 three concise sentences, front-loaded with purpose and output details. No wasted words; every sentence provides 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 no output schema, the description fully explains the return structure and usage context. It addresses tier variability (free tier exclusion) and downstream tool integration, making it complete for a simple list 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?

There are no parameters, and the schema is fully covered (100%). The description adds value by describing the output structure (key, name, class, note) and how to use it, which the empty schema does not convey.

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

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

The description clearly states the tool lists bookmakers available on the user's tier, specifying the verb 'list' and resource 'bookmakers'. It distinguishes from sibling tools by focusing on bookmaker listing, which is unique among siblings like get_match_odds or compare_lines.

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 explicitly tells when to use the tool: to obtain bookmaker keys for use in get_match_odds or compare_lines. It also provides a note about free tier exclusion of Pinnacle, guiding appropriate 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 declare readOnlyHint=true, and description adds context on timezone handling, truncation, and return fields (scheduled_at, scheduled_at_local). 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?

Well-structured with purpose first, then parameter breakdown. Slightly verbose but each sentence adds value. Could be tighter.

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?

Comprehensive for a 7-parameter tool with no output schema. Explains return fields and filtering strategies, though output structure is not fully specified.

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 provides 0% description coverage. Description explains all 7 parameters in detail with examples, defaults, and constraints (e.g., max 31 days for date_to, limit 1-200).

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?

Clearly states it lists fixtures for a calendar day or date range. Distinguishes from sibling tool list_today_matches by explaining the difference in window behavior.

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

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

Explicitly contrasts with list_today_matches, explains when to use date_to for tournament windows, and advises on filtering rather than paging.

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

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

The description elaborates beyond the readOnlyHint annotation by specifying that results include final score, red cards, and finished time (no odds), and that the tool is results-only and persists across restarts. No contradictions with annotations; it adds valuable behavioral context.

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

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

The description is concise and well-structured: a purpose sentence, a content/behavior sentence, and a bulleted args section. No wasted words; every sentence adds value.

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

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

Given the tool's simplicity (no output schema, 4 optional params), the description covers all necessary aspects: data scope (30-day cache), ordering (most-recent-first), content of each entry, and parameter details. It fully equips an agent to use the tool correctly.

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

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

Despite 0% schema description coverage, the description provides thorough parameter guidance: date format (YYYY-MM-DD), team as case-insensitive substring, league as case-insensitive substring, and limit with range (1-200) and default (50). This adds essential meaning missing from the schema.

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

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

The description clearly states it lists finished-match scores from a 30-day cache, most-recent-first, and distinguishes from live tools by noting it contains no odds and survives restart. The verb 'list' and resource 'results' are explicit, and the usage examples 'what was the score of X?' or 'yesterday's results' further clarify its purpose.

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

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

The description provides clear usage context (checking past scores, yesterday's results) and contrasts with live tools that do not survive restart. However, it does not explicitly name alternative tools like 'get_result' or 'live tools' for when not to use this tool, though the distinction is implied.

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

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

The annotations already set readOnlyHint=true. The description adds significant behavioral details: each fixture carries status, live score, clock, and summary; clock is null pre-match; timezone affects summary display. It clarifies that clock gives the real minute rather than estimation.

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 concise: a one-line purpose, a paragraph on response fields, then a clear parameter list. It front-loads the core purpose and uses minimal but sufficient detail.

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

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

Given the tool has 5 parameters, no required params, 0% schema coverage, and no output schema, the description covers all necessary aspects: purpose, output structure (clock, summary), parameter semantics, and defaults. It is complete enough for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter: sport values ('football'/'basketball'), status ('live'/'scheduled'/'finished'), league (fuzzy-matched or external id), limit (1-200, default 50), and timezone (IANA format). This adds 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?

The description clearly states the tool lists today's fixtures in UTC, with the example usage 'what games are on today / right now?'. It specifies the verb 'list' and resource 'fixtures', distinguishing it from siblings like 'list_events' which may cover a different scope.

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

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

The description provides clear context for when to use the tool (current day's matches) and explains all filter parameters (sport, status, league, limit, timezone) with defaults. However, it does not explicitly state when not to use it or compare with sibling tools.

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

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

Beyond the readOnlyHint annotation, the description details the output components, behavior on ambiguity (status 'ambiguous', ask_user prompt), and edge cases (favorite is best-effort). This fully discloses the tool's behavior.

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

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

The description is well-structured with a clear purpose first, then parameter explanations, then edge cases. Every sentence adds value without redundancy. It is appropriately detailed for 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?

Given no output schema, the description fully explains the return values and behaviors. It covers all parameters, handles ambiguity, and is self-contained. Sibling context is provided via the sibling list, but the description itself is complete.

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

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

With 0% schema coverage, the description thoroughly explains each parameter: query as natural-language, timezone as IANA, sport filter, date format. It includes examples and usage notes, adding essential meaning 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?

The description clearly states the verb 'Get' and the resource 'basics for a match', listing specific outputs (score, live status, kickoff, favorite). It distinguishes itself from siblings like get_match_odds by emphasizing a single call for basic info.

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

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

The description provides implicit usage context (e.g., 'No betting knowledge needed', handling ambiguous queries with ask_user) but does not explicitly compare to sibling tools or state when to avoid. The guidance for ambiguous queries is helpful.

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?

Aligns with readOnlyHint annotation, adding details: truncation drops quiet fixtures, sorting by signal, exclusion of finished from 'live' status, and pre-computed signals. No contradictions.

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?

Well-structured with front-loaded summary, sibling context, behavioral details, then parameter list. Slightly verbose but every sentence adds value; could be tightened slightly.

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

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

Given 10 parameters, no output schema, and minimal annotations, the description covers all essential aspects: purpose, usage context, parameter meanings, behavioral traits, and exclusions. Return values are implied (status, score/clock, signal). Complete for the tool's 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 coverage is 0%, but the description provides detailed explanations for all 10 parameters, including allowed values (e.g., sport: football/basketball), defaults, and constraints (limit max 100). This fully compensates 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?

Clear verb+resource: 'Scan today's whole slate' with specific scope (fixtures, value/arb signal). Distinguishes from siblings by stating it's the batch alternative to looping find_match/get_sharp_line and contrasts with get_opening_line for 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?

Explicitly states when to use (scan today's slate in one call) and when not to (for line movement, use get_opening_line). Names specific sibling tools (find_match, get_sharp_line) as alternatives, providing clear decision 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 declare readOnlyHint=true, which is consistent. The description adds substantial behavioral detail: the statistical model (bivariate-Poisson, Dixon-Coles), de-vigging process, and the fact it's market-implied not a prediction. It also notes one-call-only behavior.

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

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

The description is front-loaded with purpose and structured with a summary paragraph then arg list. Though it is somewhat verbose, every sentence adds value and there is no redundancy. A tighter second sentence could be made, but overall well-organized.

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

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

Given no output schema, the description thoroughly explains the return: top-K scorelines, probabilities, goal rates, and the ah_ev_check verification. It covers the football-only constraint, single match scope, and the model used. This is sufficient for an agent to invoke 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?

With 0% schema description coverage, the description fully compensates by explaining each parameter: query (natural-language fixture with examples), sport (only football), date (UTC disambiguation), and top (scoreline count with defaults). This adds critical meaning beyond the schema types.

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 it computes 'market-implied correct-score probabilities for ONE football match' with a specific verb (inverts) and resource (score grid). It distinguishes from siblings by being exclusively about score probabilities and not comparison or line finding.

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 plainly states 'Football only, one match per call' and explains optional params for disambiguation. However, it does not explicitly tell when to avoid this tool or compare with alternatives like compare_prob.

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