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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It clearly indicates a read-only information operation and lists the exact output fields. While it does not mention error cases or authentication requirements, the phrase 'API key currently in use' conveys the required auth context sufficiently.

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

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

The description is a single, complete sentence with no redundancy. It front-loads the action and immediately lists the relevant returned fields, making it easy to parse quickly.

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 tool takes no parameters, has an output schema, and the description lists the expected output fields. There is no missing information that would prevent an agent from invoking the tool correctly or interpreting its purpose.

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 zero parameters and schema coverage at 100%, no parameter explanation is needed. The description reinforces that the only implicit input is the currently authenticated API key, adding context beyond the empty schema.

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

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

The description states a clear verb ('Get'), resource ('API key currently in use'), and specific data points (tier, credits remaining, billing period). This distinguishes it clearly from sibling tools that focus on odds, sports, pricing, or signup flows.

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 context is clear: use this tool when an agent needs account status, credit balance, or billing period for the current API key. It does not explicitly mention exclusions, but among siblings it is the only account-info operation, so the intended usage is well 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?

With no annotations, the description carries the full behavioral burden and it delivers: it describes how the tool scans the whole board, uses the no-vig engine, filters to bets +EV at user-bettable books, ranks by edge, returns edge_alerts, and excludes certain bet types. It also notes the tool is scoped to the user's books. No annotation contradiction exists because there are no 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 structured well: a hook, a tight mechanism sentence, exclusions, and a parseable argument list. It is slightly verbose in its middle explanation but every clause adds useful behavior. It earns its length, but 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?

This is a read-only discovery tool with five params, many resulting context signals, and an output schema is present. The description covers scope, exclusions, ranking logic, parameter meanings, and how it differentiates from the closest sibling. An agent has enough to correctly select and invoke the tool without needing to ask about absent details.

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 zero inline parameter descriptions, so the description is the only source of parameter semantics. It provides a meaningful one-line gloss for all five parameters, including sport_key example, region options, books meaning, limit default, and min_edge semantics. This fully compensates for the schema's lack of documentation.

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 clear question and answer: it ranks +EV plays for a sport. It explicitly names itself as the discovery counterpart to parlayapi_verdict and distinguishes its scope (player props, whole board) from that sibling (game moneylines). Specific behavior — scanning, grading, filtering, ranking — is front-loaded and leaves no doubt about 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 gives strong context: use this for +EV player-prop discovery across the board, and explicitly excludes prediction markets and game moneylines, telling the agent to use parlayapi verdict for a line. It also states the output is scoped to user's books, which helps an agent choose this over 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?

With no annotations provided, the description carries the full burden. It discloses that the tool aggregates across bookmakers, returns the best price per game/market/side, and describes the returned row shape. It does not discuss rate limits or authentication, but the read-only intent is clearly inferred from 'Find' and 'Returns.'

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

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

The description is compact, information-dense, and well-structured. It states the purpose, the intended use case, the output shape, and parameter meanings in a few lines, with zero filler.

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

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

Given the output schema is present, return-value documentation is handled. The description covers the core behavior, output granularity, parameter semantics, and usage scenario. Nothing essential for calling the tool correctly is missing.

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

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

The schema has 0% description coverage, but the description compensates with useful details: a concrete sport_key example ('baseball_mlb'), enumerated market choices (h2h | spreads | totals), and a clear optionality note for bookmakers. It does not specify the exact format for multiple bookmakers, but this is a minor 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 opens with a specific verb and resource: 'Find the best (highest) price for each outcome across bookmakers.' It clearly distinguishes this tool from generic odds tools like get_odds by focusing on best-price aggregation and unique per game/market/side rows.

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 a clear use case: 'Useful for line-shopping bots.' It does not explicitly name sibling alternatives or exclusion conditions, but the context is strong enough for an agent to decide when this tool is appropriate.

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

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

With no annotations for guidance, the behavior burden falls on the description. It does disclose that no API key is required and that the tool exposes a public coverage surface, which helps an agent understand it is an unauthenticated, likely read-only status endpoint. It does not describe what a covered vs. uncovered result looks like, whether there are rate limits, or how freshness/window values affect the outcome.

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 entire description is three concise sentences with no filler:' graph is also put in production. Every sentence contributes a distinct useful fact: what it returns, that no API key is required, and what the checks are.

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 the tool's overall objective and removes one major concern by saying no API key is needed. But it still leaves the optional parameters unexplained and gives no guidance on how fresh results are or how the results relate to the surrounding florian capture tool family, which matters because no annotations exist to fill those gaps.

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

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

The input schema has zero description coverage for its two parameters, and the tool description does not explain how include_warn or window_minutes influence results. The parameter names offer weak hints, but 'window_minutes' in particular lacks enough meaning without context about freshness windows or the exact computation gate.

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 ('Return') and a specific resource ('per-book coverage gates'), plus the public scope and the checks involved. It is clearly not a general odds- or pricing-related tool, so an agent can distinguish it from most siblings, though it does not explicitly contrast it with the closely related source_quality tool.

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

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

The description conveys when this is the right tool to inspect source health by defining the tool as the proof surface for freshness, normalization, database, REST-shape, and stream-shape checks. However, it does not describe when to prefer it over sibling tools like source_quality or when not to use it, leaving routing mostly implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It states the tiers and monthly subscription nature, but does not disclose important side effects or constraints, such as whether this creates a Stripe session, whether it charges immediately, whether the URL expires, or what happens after the user clicks it.

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

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

The description is compact, front-loaded with the main action, and uses a clear list for tiers and pricing. Every line provides useful information with no unnecessary prose.

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

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

The description is adequate for a simple 2-parameter checkout-link tool and the presence of an output schema covers return value expectations. However, with no annotations and no description of email semantics or the payment flow, the agent must fill in important gaps before invoking it confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It meaningfully documents the tier parameter with valid values and prices, but the email parameter is never explained beyond what the schema already shows. The tier documentation helps significantly, but the email gap prevents a higher score.

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 identifies the action ('Generate a Stripe Checkout URL') and the resource/context (user upgrade), so an agent can tell this tool is for creating checkout links. It does not explicitly distinguish it from sibling tools like parlayapi_get_pricing or parlayapi_signup, so it stops short of a 5.

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

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

The description implies when to use the tool: when a user needs a clickable URL to upgrade. However, it gives no explicit guidance about when not to use it, such as using get_pricing for pricing questions or signup for initial account creation.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It clearly discloses the return structure: average, best, and worst price per event/market/player/line, plus the special split for soccer and other 3-way markets. It does not mention auth or rate limits, but the core behavioral contract is transparent.

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 front-loaded: the main action appears in the first sentence, return behavior in the second, the 3-way market edge case in the third, and parameters are compact and useful. There is no fluff or repetition of schema mechanics.

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 is complete for a simple read-style endpoint: it explains what the tool returns, defines inputs, and gives a recommended use case. Since an output schema exists, extra return-value detail is not required. It could slightly strengthen by explicitly routing the agent away from sibling tools, but it is functionally 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?

Schema description coverage is 0%, so the description fully compensates by explaining both parameters. It gives concrete examples for sport_key and clearly documents markets as an optional comma-separated list with example values like 'moneyline,totals'.

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

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

The description states a specific verb and resource: 'Get consensus (average) odds across all bookmakers per market.' It also clarifies the unique value of the tool by naming the output concepts—average, best, and worst price per (event, market, player, line)—which distinguishes it from siblings like get_odds or best_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 provides clear usage context: it is 'a sharp baseline for line-shopping' and explains optional market filtering. It does not explicitly name alternatives or state when not to use it, but the purpose and filtering behavior are clear enough to guide an 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?

With no annotations provided, the description carries the transparency burden. It clarifies that the tool scans every event, returns arbitrage bets whose combined probability is below 100%, and even discloses a real caveat: exchange-anchored asks can have no volume. It does not explicitly state 'read-only/no bets placed', but the verbs 'scans' and 'returns' strongly imply a non-mutating action.

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 concise explanation of the discovery logic and supported market type, then a focused Args block. Every part adds operational information needed to pick and call the tool correctly.

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

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

Given that an output schema exists, the description does not need to explain return format. It adequately covers the tool's purpose, supported markets, key behavioral caveats, and all parameter semantics. It could be improved by mentioning when to choose a sibling tool like find_ev or find_middles instead.

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 must compensate fully. The Args section does exactly that: it explains each parameter's meaning (e.g., min_profit as a percentage, markets as comma separated market_keys), gives examples, states optionality, and covers behavior like exclude_exchanges dropping no-volume exchange-anchored arbs.

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

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

The description states a specific verb and resource: 'Find... arbitrage opportunities across bookmakers', then reinforces it with the technical criterion of combined implied probability under 100%. This clearly distinguishes it from siblings like parlayapi_find_ev and parlayapi_find_middles.

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 for when this tool is appropriate, especially for soccer and other 3-way markets, and notes the optional scan scope via markets. It does not explicitly name sibling tools or say 'use for arbitrage, not for EV/middles', but the use case is strongly 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?

With no annotations, the description carries the full burden, and it does well: it explains the comparison methodology, the sharp-book default, the no-vig derivation, and the special three-way soccer handling for draws. It doesn't mention rate limits, errors, or authentication, but for a data-querying tool the core analytical behavior is transparently described.

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

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

The description is well-structured: the one-line summary leads, followed by an efficient explanation of the methodology and then a clear Args list. Every sentence contributes useful information without repetitious padding.

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

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

For a 4-parameter tool with no annotations but with an output schema, the description thoroughly covers what the tool does, how it computes EV, which markets it handles specially, and the meaning of every argument. There is no significant missing context needed to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every parameter is explained with practical examples (e.g., sport_key: 'baseball_mlb', min_edge: default 2). It even clarifies optionality of markets and defaults for sharp_book and min_edge.

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+resource: 'Find positive-EV bets vs a sharp book's no-vig fair line,' which immediately tells the agent what the tool computes. It also distinguishes itself from arbitrage and middles by focusing on +EV relative to a sharp fair 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 clearly explains the intended use: compare soft book prices against a sharp book's no-vig fair line, with defaults and optional filters. It does not explicitly name alternative sibling tools or when-not-to-use, but the algorithm and inputs are concrete enough that an agent can infer 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?

No annotations are preset, so the description carries the full burden of explaining behavior. It clearly states that the tool scans available markets and returns windows, hitting numbers, and per-$100 economics, which makes the purely informational/report-like behavior transparent. It does not mention auth or rate limits, but nothing about the description implies harmful side effects.

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 thorough but every sentence earns its place. The definition, illustrative example, coverage scope, output economis, and parameter documentation are organized and front-loaded, making it easy for an agent to quickly understand and invoke the tool.

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

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

Given the tool's complexity, the description fully covers inputs, optional defaults, scope of search, and the economics of the return. The output schema handles specific return-field expectations, and the description provides the tactical context an agent needs to call this tool correctly and interpret its results.

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

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

Schema description coverage is 0%, so the arguments section is the sole source of parameter meaning. It explains all four parameters: sport_key with examples, min_gap as window width, market s a comma-separated optional filter, and include_props as a boolean toggle. This adds substantial value 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 uses a specific action ('Find cross-book middle opportunities') and thoroughly defines what a middle is with a concrete example. It calls out the scanned markets (totals, spreads, player props), which clearly distinguishes it from sibling tools like parlayapi_find_arbitrage and parlayapi_find_ev.

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 execution context by specifying sport_key requirement, market filtering, and prop inclusion, and it names the kinds of outcomes returned. It does not explicitly contrast itself with find_arbitrage or find_ev, but the intended use is easy to infer from the detailed middle-explanation.

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 operation is clearly a read operation ('Get...'), and 'from all configured bookmakers' adds meaningful scope. However, with no annotations, there is no disclosure of rate limits, pagination, data freshness, or other behavioral caveats. The description is not misleading, but it does not go beyond the basic read 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 starts with a one-sentence purpose and then uses a tight Args block with no filler. Every line adds concrete parameter information, and the format is easy for an agent to scan quickly.

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 is sufficiently complete for a callable tool: all five parameters are explained with examples and value domains, the output schema presumably covers the return shape, and there is no missing critical context for making a correct invocation.

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

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

Schema description coverage is 0%, so the parameter documentation in the description is critical. It fully compensates: it gives concrete examples for sport_key, lists valid markets and regions, provides optional bookmaker examples, and explains the odds_format choices. Every parameter in the schema is given meaningful guidance.

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

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

The description clearly states the exact operation: 'Get game-level odds for a sport'. It also scopes the tool to all configured bookmakers and identifies the key inputs, making its role easy to distinguish from prop-focused or best-line-focused siblings like parlayapi_get_props or parlayapi_best_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 strongly implies when to use this tool — when game-level odds for one or more configured bookmakers are needed — but it does not explicitly name alternatives or give when-not-to-use guidance. An agent must infer that props, best-lines, or live odds belong to 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?

No annotations are provided, so the description carries the burden. It clearly states no API key is required and that the pricing is public/current. This discloses authentication needs and scope, though it could go further on rate limits or output semantics, but the output schema covers these.

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 punchy sentences with zero filler, front-loaded with the core action, followed by auth context, and a practical usage scenario. Every sentence earns its place.

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

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

For a zero-parameter, no-auth, public data accessor, the description fully covers what the agent needs to know. The output schema exists for any return-value details, and the usage context clearly tells the agent when to invoke it.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds relevant contextual meaning (no auth, current pricing) beyond the schema, making a baseline 4 appropriate here.

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 states a specific verb ('Return') and resource ('current public pricing table'), clearly distinguishing this from sibling commerce/pricing operations. The phrase 'public' clarifies scope and positions it as a read-only informational tool.

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

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

Explicitly tells the agent when to use this tool: when explaining which tier unlocks a workflow before sending a checkout link. This gives clear contextual context even without naming a specific alternative, and distinguishes it from checkout_link.

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?

There are no annotations, so the description carries the full burden. The wording Get player prop odds strongly implies a read-only operation, and the description discloses the filtering behavior for player and futures inclusion. It does not mention pagination, response properties, or whether returned odds are live or cached, but these are partially covered by the output schema being available.

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, front-loads the purpose in the first sentence, and uses a clear Args block. The example lists are useful and not padded with filler, so the overall structure is easy for an agent to parse.

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 five-parameter tool with zero schema description coverage, this description covers all inputs and gives useful examples. It does not describe sibling differentiation or note that some prop markets may only be relevant for certain sports, but the output schema plus the parameter coverage make the tool generally callable.

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 every parameter. It gives concrete sport_key examples, market names like player_points and player_strikeouts, bookmakers like prizepicks and draftkings, the player filter behavior, and the include_futures default.

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 specific verb and resource: Get player prop odds for a sport. The resource is clearly distinct from more general tool names like get_odds, but it does not explicitly differentiate itself from any sibling tool.

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

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

The description implies usage through its parameter guidance, showing how to provide sport_key, markets, bookmakers, player, and include_futures. However, it does not state when to prefer this tool over get_odds, get_pricing, live_odds, or or any other sibling, nor does it give exclusions for when not to use it.

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

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

No annotations are provided, so the description carries the behavioral burden. It makes the read-only 'list' nature and the key-format convention clear, but it does not explain how active_only affects the result, whether inactive sports are included, or whether responses are paginated.

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 short and front-loaded: purpose first, usage context second, and representative examples last. Every sentence earns its place, and nothing is wasted.

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

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

For a simple one-optional-parameter list tool with an output schema, this is mostly complete: the agent understands the return resource and how to use its result later. It still lacks guidance on the active_only parameter and on how this tool relates to parlayapi_live_sports, so some agent misunderstanding remains possible.

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

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

Schema description coverage is 0%, and the description does not mention the active_only parameter at all. The parameter's name and default in the schema hint at its purpose, but the description does not compensate for the missing schema documentation or explain when to pass false.

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: 'List available sport keys' and adds concrete examples of the expected key format. It is clear about what the tool does, though it does not explicitly distinguish itself from sibling list-like tools such as parlayapi_live_sports.

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 line 'Use these in subsequent calls' gives clear context for when the tool should be used: early in a workflow to obtain sport keys for later calls such as odds, props, or pricing. It does not name alternatives or exclusions, so it falls just short of a 5.

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

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

With no annotations, the description takes on full behavioral disclosure. It clearly states that no API key is required, that the tool returns a public payload, and that it is a demo/discovery surface with limited capabilities compared to paid endpoints. This is meaningful, though it does not cover rate limits or detailed response semantics.

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-front-loaded, with the core purpose of claims in the first sentence and additional context in the following sentences. Every sentence adds information to the agent from the scope to the no-key requirement to the demo limitation.

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 payload tool with an output schema, the description is nearly complete: it covers what is returned, the demo nature, the access requirements, and the limitation vs. paid endpoints. The only meaningful gap is the lack of parameter guidance, which is already penalized above.

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 needed to explain 'limit' and 'sport_key', but it does not. The parameter names and defaults are minimally suggestive, but the agent is left guessing what limit bounds, whether sport_key is required for filtering, and what an empty value means.

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

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

The description states a specific verb and resource: 'Return the public best-line command center payload.' It then specifies what the result shows (current games, participating books, best available real prices on the /live dashboard preview). It also distinguishes itself as a discovery/demo surface from the paid odds endpoints among its siblings.

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

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

The description tells the agent this is the free, no-API-key discovery/demo surface and explicitly says it is 'not a substitute for the paid odds endpoints.' It gives clear context for when to use it, though it does not name the exact sibling tools to call instead for full odds.

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

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

With no annotations provided, the description carries the sole burden of disclosing behaviors. It usefully states that no API key is required and that it returns search results for teams, players, and sport_keys. It does not mention any response shape, paging, or rate limits, but both the search nature of the tool and the presence of an output schema reduce the need for exhaustive 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 only a few short sentences, opens with the command and resource, and includes a functional note about no API key required. It avoids repetition of the tool name and every word adds either use-case or operational context. Very strong structure.

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

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

Given that this is a simple search operation with one required parameter and an output schema present, the description leaves the agent with a sane, full picture: what to search, what the result's role is, and a key operational note (no API key). It does not break down the response format, but the existence of an output schema makes that unnecessary.

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 gives only property titles and no descriptions (0% coverage). The description compensates for 'q' with its natural-language lookup purpose, and implies that 'limit' exists to cap a search result, but explicitly meaning the limit sentantic is left to the schema's default value of 25. That is enough basic understanding for an agent, but it is not comprehensive.

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 action ('Search live teams, players, and sport keys') and wraps it in a concrete use case. It distinguishes the tool from siblings by emphasizing that it maps natural-language names to the exact sky_key needed for subsequent calls. This is specific, not tautological, and covers the tool's role.

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 a clear when-to-use statement: when a user asks for a team, player, or league by natural-language name and the agent needs the exact sport_key for the next step. It does not explicitly name alternatives or say when NOT to use, but in a sibling list dominated by odds, props, and sports data calls, the intended context is easy to infer.

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

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

With no annotations provided, the description carries the full burden. It discloses that no API key is required and describes what is returned (sport keys plus live event and book counts). For a simple, parameterless read-style tool, this is adequate transparency, though it does not discuss refresh timing or whether the list is exhaustive.

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 short sentences with no filler. The core purpose is front-loaded, and each sentence adds meaningful information: what it lists, that no API key is needed, and what the response contains.

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

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

For a zero-parameter tool with no annotations, the description is complete for safe invocation. It states the endpoint concept, auth requirement (no API key), output contents, and high-level purpose. The output schema can cover the detailed return shape, so no meaningful gap exists.

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

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

The tool has zero parameters and schema coverage is 100%, so the schema fully describes the input contract. The description adds relevant context by stating no API key is required, which is useful operational information. This aligns with the baseline 4 for a no-parameter tool.

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

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

The description uses a specific verb ('List') and identifies the exact resource: currently active live sports on the retail /live surface. It also clarifies that it returns sport keys plus live event/book counts, which clearly separates it from siblings like parlayapi_list_sports or parlayapi_live_search.

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 for when to use the tool: to discover what live sports are currently active on the retail /live surface. It does not explicitly name alternative tools or state when-not-to-use, but the purpose is specific enough that an agent can reasonably select it without confusion.

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

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

With no annotations provided, the description properly carries the behavioral disclosure. It reveals the critical anti-enumeration behavior—always returning ok=true regardless of email existence—and tells the user that the recipient is emailed. This addresses the most important behavioral and security traits.

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 tightly-constructed sentences. The primary action is stated first, followed only by the essential behavioral caveat. There is no redundant or extraneous content.

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

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

The tool has only one required parameter, a straightforward input schema, and an output schema, so the description does not need to detail explicit return format. It provides the essential operation, the email delivery outcome, and the return consistency behavior—enough for an agent to call and interpret 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 email as a string, and schema description coverage is 0%. The description adds the meaningful context that the email must correspond to an existing ParlayAPI account and is the destination for the magic link. For a single simple parameter, this is sufficient.

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 relationship ('Email a magic-login link for an existing ParlayAPI account') and clearly scopes the tool to account authentication. The phrase 'existing ParlayAPI account' distinguishes it from the sign-up flow among the 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?

The description makes it clear this applies only to existing accounts, which implies using signup for new accounts. It does not name the signup alternative explicitly, but the context is sufficiently clear for an agent to select this tool over 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?

No annotations are provided, so the description carries the full burden. It discloses the no-vig nature, book-scoping behavior, correlation warnings, EV reporting, and payout computation. It does not explicitly state that no bet is placed or that the result is advisory-only, though the wording 'grade', 'should you bet it' strongly implies analysis rather than execution.

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 opening line is immediately informative, the output list is front-loaded, and every sentence adds value. The inline leg example is long but earns its place given the nested leg shape. No redundant marketing language or restatement of the tool name.

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

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

The description covers the core use case, input format, optional stake/book controls, and book scoping prerequisites. Combined with the existing output schema, an agent can invoke the tool correctly. The only completeness gap is the lack of mention of kelly and bankroll, which have defaults but no description here or schema coverage.

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

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

Schema description coverage is 0%, so the description must compensate. It explains legs with a concrete example, defines region values, describes books as CSV override, and clarifies the purpose of stake and book. However, kelly and bankroll appear in the schema but are absent from the Args description, which is a modest gap for optional parameters.

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 clear imperative: 'Grade a multi-leg parlay: should you bet it, and at which book?' It names the specific resource (a multi-leg parlay), the action (grade/evaluate), and the concrete outputs: fair no-vig price, best book, EV, weakest leg, correlation warnings, payout. This strongly distinguishes it from the single-bet sibling parlayapi_verdict.

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: 2 to 12 legs, parlay is one slip rather than best-of-each, and book scope is controlled by parlayapi_set_bettable_books or region/books parameters. It doesn't explicitly name alternative tools for single-bet verdicts or pure EV lookups, so 'when not to use' is only 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?

With no annotations, the description carries the full burden and does disclose the core behavior: the tool persists user book preferences and affects future parlayapi_verdict recommendations. It also documents the precedence rule that books overrides region. It does not discuss response behavior, errors, or how repeated calls should be handled, but the main side effects are covered.

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, with no filler. The core purpose and trigger come first, and the Args section adds critical parameter details without unnecessary context. Every sentence contributes to correct invocation.

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

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

For a two-optional-parameter configuration tool, the description covers when to call, what to pass, how parameters interact, and why it matters. It is slightly ambiguous about what happens on a second call or if neither parameter is provided, but for a single-call setter this is not a major 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 must compensate and does: it lists region's allowed values (us | eu | uk | au | ca) and explains books as an exact CSV with an example. It also clarifies the relationship between the two parameters with 'Overrides region.' This adds genuine 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 uses a specific verb and resource: 'Remember which books the user can bet at' and explains the downstream effect on parlayapi_verdict. This clearly separates it from all sibling tools, which are data/retrieval operations rather than a user-context setter.

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 a concrete trigger: 'Call this once when a user tells you where they bet', with an example. It also says parlayapi_verdict will automatically use this setting so region/books do not need to be passed every call. It does not explicitly mention when not to call or how to handle updates, but the context is clear.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses the returned values (API key, magic-login URL, Stripe upgrade URL), idempotency, the exists=true case, and the intentional non-exposure of existing API keys for security. This gives the agent strong behavioral expectations.

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 structured with key behavior first, then usage guidance, then parameter details. It is slightly dense and the agent_id default is repeated from the schema, but every section earns its place and no irrelevant information is present.

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 3-parameter tool with one required param, the description fully covers what happens, what is returned, the idempotent edge case, and the follow-up step for the user. The Agent can safely invoke this tool and handle its response.

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 Args section is essential and fully compensates. It explains email is the user's address, intended_use is optional and used for analytics, and agent_id identifies the calling agent. Compared to the minimal schema, this is a complete semantic mapping.

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: 'Create a free-tier ParlayAPI account for the given email.' It clearly distinguishes signup from the other ParlayAPI siblings by focusing on account creation and conveying what the call returns. No ambiguity about what this tool does.

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

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

The description gives clear context: 'Use this when a user wants to start building with ParlayAPI and does not have a key yet.' It also explains the follow-up action after signup. It does not explicitly name alternative tools or state when not to use it, so it stops 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.

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

No annotations are provided, so the description carries the full burden. It usefully discloses that the endpoint is 'public' and does not require an API key, which is meaningful behavioral context. However, it does not describe what happens when freshness data is missing, whether there are rate limits, or how quality is computed, leaving some behavior undocumented.

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 focused sentences, no fluff. The primary purpose is front-loaded, followed by the useful auth note and a concrete use case. Every sentence earns its place.

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

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

For a simple public metadata query with an output schema present, the description covers the essential context: purpose, access requirements, and when to use it. The only notable gaps are parameter meaning and explicit sibling alternatives, but they do not stop an agent from successfully invoking the 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%, and the description does not mention the `limit` or `minutes` parameters at all. Although their names and defaults are somewhat self-explanatory, an agent has no guidance on how to choose values for these parameters or what constraints apply. Since the description does not compensate for missing schema docs, this dimension is weak.

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

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

The description clearly states a specific verb ('Return') and a distinct resource ('public per-source freshness and quality metadata'). This differentiates it from siblings like parlayapi_get_pricing or parlayapi_get_odds because it focuses on metadata quality rather than pricing, odds, or betting execution.

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 a concrete context: 'prove that rows are flowing from each source before choosing books for a customer workflow.' This tells an agent when the tool is useful, though it does not explicitly list exclusions or alternative 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?

Even though no annotations are provided, the description goes into substantial behavioral detail: it returns no-vig fair price, best available price and book, EV grading, line-shopping nudge, a verdict label, Kelly stake feedback, region-scoped recommendations, and the edge_alert edge case. It also reveals that bettable-books configuration is remembered per key, so the agent understands persistence and configuration behavior without inspecting state.

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 unusually well structured: a high-level verdict, a list of outputs, explicit when-to-use guidance, scoping notes, then a complete Args block with minimal redundancy. Every sentence earns its place, and the most important purpose and usage guidance are 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?

For a complex, 14-parameter tool, this description is complete: it covers the full input space, expected outputs, exceptions (NO_DATA), configuration dependencies, price-risk edge conditions, and the alternative behavior for +EV stakes. It leaves little room for an agent to call the tool without understanding what it needs or what it will produce.

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, but the description's Args section covers every parameter with practical semantics: sport key format, side options, market values, home/away vs team alternative, player requirement, price override semantics, region values, books CSV format, bankroll meaning, and kelly. This is far beyond the bare schema and fully compensates for the absence of schema-level 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 opens with a plain-English purpose ('Should I bet this?') and states the tool is a one-call verdict for a specific bet. It clearly identifies the resource (a bet verdict) and the operation (returning fair price, best price, EV grading, and a verdict), which distinguishes it from sibling tools that focus on odds, props, or parlay verdicts.

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 explicit when-to-use guidance: use it when a user asks whether a specific bet is worth making or whether they are getting a good number. It also tells the agent NOT to stitch /ev + /consensus + /best-line together, which is a concrete alternative that would otherwise be a common mistake.

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