BirdieAPI

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

Annotations already cover read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful behavioral context by stating the credit cost and clarifying that hole stats are aggregated from every round on the course; it does not contradict the annotations.

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

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

The description is compact and front-loads the core purpose before giving the multi-course conditional and credit cost. It is efficient overall, though the course_id note duplicates schema text and the opening phrase 'Use for a course' is slightly less direct than a verb-first formulation.

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

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

With full schema coverage, annotations covering safety, and an output schema available, the description supplies enough to invoke the tool correctly: data scope, the course_id condition, and cost. It could be more complete by clarifying its relationship to get_course_history, but nothing essential for calling the tool is missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the multi-course condition for course_id. The description repeats that course_id condition but adds little beyond the schema, such as no meaningful detail on league or tournament_id semantics, so the baseline 3 applies.

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

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

The description clearly states the resource and scope: course setup for a tournament (par, yards per hole) plus per-hole performance stats from every round. It is specific about what data is returned, but it does not explicitly distinguish itself from the sibling get_course_history, so it falls short of a 5.

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

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

It gives clear usage context (course as set up for a tournament) and a conditional instruction: pass course_id when the tournament uses more than one course. It does not state when not to use this tool or name an alternative sibling, so it is not a full 5.

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

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

Annotations already cover the read-only, idempotent, closed-world and non-destructive profile, so the bar is lower. The description adds genuinely new context: the explicit cost of 5 credits and the shape of what comes back (finishes, rounds, strokes versus the field, summary).

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

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

Front-loaded with the usage signal in a single dense sentence, then the cost. No filler, though the nested parentheticals make it slightly harder to scan than it needs to be.

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

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

With an output schema and fully described parameters, the description only needs the mode selection and cost, both of which are present. It does not say what happens if neither tournament_id nor course_id is supplied, a small remaining gap for a 4-parameter tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond it by framing tournament_id and course_id as two alternative look-up modes and clarifying that any edition's tournament_id works, which helps the agent pick the right parameter rather than both.

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

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

States a specific resource (a player's record at one tournament across years, or at one course across tournaments) with the exact parameters that select each mode. This clearly separates it from siblings like get_player_results or get_course, which cover single-context results rather than a cross-year history.

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

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

'Use for course or event form' plus the parenthetical instructions on which id to pass give concrete, actionable selection guidance. It stops short of naming an alternative sibling or stating when not to use it, so it is a clear 4 rather than a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description adds real value beyond them: the 5-credit cost and the specific tie-break rule that 'making the cut beats missing it'. Return shape is disclosed too. Not fully exhaustive on pagination/limits, hence 4.

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?

One front-loaded sentence that opens with the use case and packs the key facts (contents, filter, cost) with no filler. The enumeration of return contents is slightly redundant given an output schema exists, keeping it from a 5.

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

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

With an output schema present, the description needn't detail return values, and it still conveys cost, scoping, and comparison semantics. Sufficient for an agent to call correctly; only minor gaps around how player IDs are resolved across leagues.

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

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

Schema description coverage is 100%, so the schema already documents player_a, player_b, league, and season. The description only restates season filtering and adds no format, ID-source, or defaulting guidance beyond what the schema says. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('compare two players') and enumerates exactly what the comparison contains: shared tournaments, finishes, head-to-head winner logic, round-by-round strokes, and a summary. This inherently separates it from single-player siblings like get_player_results or get_player_stats, though no sibling is named explicitly.

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

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

'Use to compare two players' gives clear context, and 'Filter by season' plus 'Costs 5 credits' tell the agent how to scope and budget the call. No explicit when-not or named alternative (e.g., use get_player_results for a single player) is given, so it stops short of a 5.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely non-derivable context: earnings are absent for DP World Tour and LIV, season points exist only for FedEx Cup/PGA Tour, playoffs are included, and the call costs 2 credits. Credit cost and league-conditional data availability are exactly the traits annotations cannot express.

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

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

Front-loaded with the use case, then a dense but purposeful enumeration, closing with the cost sentence. Every clause carries information, though the long field list overlaps somewhat with the existing output schema and could be trimmed without loss.

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

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

With an output schema present, the description needn't document return shapes; it still covers the use case, league-dependent data caveats, and cost. Combined with 100% schema coverage and full annotations, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaning for the `league` parameter by explaining which output fields vary by league (earnings for DPWT/LIV, points for PGA). It says nothing extra about `limit` or `tournament_id`, which the schema already documents.

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

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

States a specific verb ('use for a tournament's results') and enumerates the exact resource contents: full field in finishing order with position, status, score to par, strokes, per-round detail, earnings and season points. The 'every player in the field' scope implicitly separates it from single-player siblings like get_scorecard and get_player_results.

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

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

'Use for a tournament's results' gives a clear triggering context, and the enumerated contents signal the full-field use case. It does not explicitly name an alternative tool or state when-not to use it (e.g. single-player lookups), so it falls short of a 5.

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

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

Annotations already cover read-only, idempotent, non-destructive and closed-world, so the description is free to add the behavior that matters: a concrete credit cost ('Costs 5 credits') and per-source data availability limits (earnings empty for DPWT and LIV; no Race to Dubai or CME Globe points; tournament stat lines only for PGA Tour from 2011). These are exactly the caveats an agent cannot get from structured fields and would otherwise produce silently wrong answers.

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 usage directive is front-loaded and the dense stat enumeration is grouped logically by data source rather than dumped as a flat list. It is long, but nearly every clause (glosses, league restrictions, credit cost) earns its place; a bulleted structure would read faster than the single run-on enumeration.

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

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

With an output schema present, the description needn't explain return values, and it correctly spends its budget elsewhere: stat semantics, league/stat compatibility, credit cost, and sample-size context ('with each player's sample'). Combined with 100% schema coverage and full annotations, nothing needed to call this correctly is missing.

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

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

Schema coverage is already 100%, so the baseline would be 3, but the description goes further and glosses the entire stat enum semantically — sg_par3/4/5 are defined as strokes versus field on those hole types, field-strength adjusted, and each stat is grouped by source (rounds/holes, results, tournament stat lines). That is real meaning the schema's bare 'The stat to rank' does not convey, and it is the parameter most likely to be mis-selected.

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 opening clause states a specific verb-style trigger and resource: 'a season's leaders in one stat, with each player's sample.' That scope (season-level, single-stat ranking) implicitly separates it from get_leaderboard and get_player_stats, but no sibling is named explicitly, so the differentiation is inferred rather than stated.

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

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

'Use for a season's leaders in one stat' is an explicit usage trigger, and the stat glossary adds conditional guidance (sg_* is 'PGA Tour and Korn Ferry Tour only, score-based, not shot data'; cup_points is 'PGA Tour only'). It stops short of naming when to prefer a sibling such as get_leaderboard or get_player_stats, so it lacks explicit 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?

The description successfully adds crucial behavioral context by stating the cost ('Costs 5 credits'). This information is critical for agent planning but is not available in the annotations.

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

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

The tool uses a single, dense sentence to communicate an extremely high volume of functional information efficiently without waste.

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?

By listing nearly every piece of data included in the overview, the description leaves no ambiguity about the scope of the information returned, making it maximally complete for an agent.

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?

Since schema description coverage is 100%, the schema already documents the parameters. The description provides no additional meaning or context for the 'player_id' or 'league' 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 provides an extremely detailed breakdown of the resource, listing specific data points like 'profile,' 'career totals,' 'our current rating,' and 'last ten results,' making its function perfectly clear.

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

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

The description implies usage by detailing the type of data retrieved (a comprehensive overview), but it fails to specify when to choose this tool over similar siblings like 'get_player_stats' or 'get_player_results' in a workflow.

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 mark the tool as read-only, idempotent, non-destructive, and closed-world. The description adds valuable behavioral context beyond that: newest-first ordering and a concrete cost of 5 credits. It could further clarify pagination or rate-limit behavior, but the credit cost is a meaningful addition.

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

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

Two dense sentences, front-loaded with the core purpose and followed by ordering, filtering, and cost. Every clause carries information; there is no filler.

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

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

An output schema exists and annotations cover safety traits, so the description need not explain return structure. It adequately covers the tool's data scope, ordering, filtering, and cost, though it remains silent on how this tool relates to similar scoring siblings.

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

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

Schema description coverage is 100%, so all five parameters are fully documented in the schema. The description only mentions season filtering, adding no substantive meaning beyond what the schema already provides for limit, offset, league, player_id, and season. This matches the baseline for high schema coverage.

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 scope: a player's tournament-by-tournament record including finish, score, earnings, and round-level details. This is more granular than get_player or get_player_stats, but it does not explicitly distinguish itself from siblings like get_scorecard, 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 phrase 'Use for a player's tournament-by-tournament record' gives implied usage context, and 'filter by season' clarifies one filtering option. However, there is no explicit guidance on when to choose this tool over get_player_stats, get_scorecard, or get_head_to_head, which is a notable gap in a crowded sibling set.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful non-schema behavior: a 5-credit cost and coverage limits (sg-by-hole-type only for PGA Tour and Korn Ferry, score-based not shot data, some fields only 'where they exist'). It stops short of stating response shape or empty-result behavior, but it exceeds the annotation baseline.

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

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

Front-loaded with "Use for..." and composed of one dense, waste-free sentence; the credit cost is the only trailing element. It is close to a run-on list, which costs a little readability, but every clause carries 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?

An output schema exists, so the lengthy return-value inventory is partly redundant with structured data — the description would be better spent on sibling routing. Still, the credit cost and per-league metric availability are context an agent genuinely needs before calling, and nothing critical is missing.

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

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

Schema description coverage is 100%, so player_id, season, and the league enum are fully documented in the schema. The description references league scope for certain metrics but doesn't map that to the league enum values or clarify interactions (e.g. kornferry vs golf), so it adds little beyond the schema. Baseline 3 applies.

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

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

The description enumerates exactly what comes back for a player-season: results, scoring average, hole-by-hole scoring, strokes-vs-field by hole type, and where available driving/greens/putts. That is a clear, specific resource statement, but it never distinguishes itself from the overlapping sibling get_player_results or get_player, so an agent must still guess which to call.

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

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

"Use for a player's season in numbers" gives an implied context, and the league caveats hint at when certain fields are unavailable. However, there is no explicit when-not guidance and no mention of get_player_results / get_player / get_scorecard as alternatives, despite obvious overlap in return content.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior, so the description adds value by disclosing the credit cost ('Costs 2 credits'), the adjustment methodology (field strength, recency weighting), and the past-date capability. The one gap is it doesn't mention the default result cap or ordering stability, though limit is documented in the schema.

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

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

Three short sentences, front-loaded with the use case, followed by the rating interpretation and the historical option, with the cost noted last. No filler sentences and every clause contributes.

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

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

With an output schema present, return values needn't be explained, and the description covers use case, metric semantics, historical mode, and cost. It could be slightly more complete by noting default league/limit behavior, but it is sufficient for correct invocation.

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

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

Schema coverage is 100% and all four parameters (as_of, limit, league, min_rounds) are fully described there, so the description's note about passing as_of largely restates the schema. Baseline 3 applies since the schema carries the parameter burden.

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

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

States a specific verb+resource ('our strokes-versus-field rating for every player') with scope ('active in the past year') and ordering ('best first'), which clearly separates it from sibling stats/leaderboard tools. The interpretation rule for a 2.0 rating further nails down what the resource actually means.

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

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

'Use for who is playing best' gives an explicit triggering question, and 'Pass as_of for the ratings on a past date' covers the historical case. It does not explicitly name a sibling tool (e.g., get_player_stats or get_leaders) as the alternative, so routing is implied rather than spelled out.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds two things annotations cannot: the credit cost ('Costs 1 credit') and the payload contents (courses, defending champion). Return format is left to the output schema, which exists, so no further gap is critical.

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

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

A single tight sentence: purpose and scope first, enrichment second, cost last. Every clause carries information and nothing is repeated from the structured fields beyond a brief default reminder.

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

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

An output schema exists, so return values need not be spelled out, and both parameters are fully covered by the schema plus annotations. The description supplies the missing pieces an agent needs to choose the tool: temporal scope and credit cost.

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

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

Schema description coverage is 100%, so both parameters (days, league) are fully documented in the schema with defaults, bounds and the enum list. The description only restates the default-30-day window, adding no syntax or semantics beyond the schema. Per the rules, a 3 baseline is appropriate when the schema does the heavy lifting.

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 pair: return what is on now and next, meaning tournaments in play or starting within N days, enriched with courses and the defending champion. That is far more concrete than the bare name 'get_schedule'. It does not, however, distinguish itself from the sibling list_tournaments, so a 5 is not warranted.

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

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

'Use for what is on now and next' gives a clear selection context, and the default-30-days window implies the intended scope. There is no explicit when-not clause or routing to list_tournaments, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive behavior, so the safety profile is covered. The description adds a genuinely useful piece of non-structured information: the call costs 2 credits. Beyond that it says nothing about error behavior, missing-cut players, or data availability.

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

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

A single front-loaded sentence that opens with the use case before listing returned fields. The output enumeration is long but each clause (par, yards, result, out/in, strokes vs field) tells the agent something about match quality; minor tightening is possible.

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

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

An output schema exists, so the description needn't explain return structure, yet it briefly does so to aid selection. With two required params fully documented in the schema, the cost note, and the safety profile in annotations, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, with all three parameters documented including the league enum default and id sources (get_leaderboard, list_tournaments). The description only implies player_id and tournament_id via 'one player's tournament hole by hole' and adds no format or constraint detail beyond the schema, so baseline 3 applies.

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

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

Specific verb-plus-resource: retrieves one player's hole-by-hole scorecard for a tournament, and enumerates exactly what comes back (per-hole strokes, par, yards, result, course, out/in, strokes vs field). It is immediately distinguishable from siblings like get_leaderboard or get_player_results, which do not go hole by hole.

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

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

The opening 'Use for one player's tournament hole by hole' sets a clear usage context and scopes it to a single player in a single tournament. It does not name an alternative (e.g., get_leaderboard for field-wide standings) or state when not to use it, so it falls 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?

Beyond the annotations, the description discloses snapshot cadence, historical-coverage limitations, cost in credits, and an important usage constraint: prices are market information and must not be used for stakes, payouts, profit calculations, or betting recommendations. This is substantial behavioral context that annotations alone would not 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 front-loaded and every sentence carries useful information, including coverage details, query modes, cost, and compliance constraints. It is dense and somewhat parenthetical, but not wasteful.

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 exists, the description does not need to explain return values. It covers the important context: market scope, snapshot timing, historical caveats, query modes, credit cost, and usage restrictions, leaving little an agent needs to infer before calling 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?

Schema description coverage is 100%, so the baseline is 3. The description adds useful semantics about query modes and how tournament_id, season, and player_id relate to scope, though it does not explain every parameter such as limit or bookmaker.

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: pre-tournament winner prices for the four men's majors by sportsbook, including opening and latest prices. It clearly distinguishes this from sibling tools like get_leaderboard or get_head_to_head by naming the exact market and explicitly excluding round, matchup, and finishing-position markets.

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

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

It gives clear selection guidance among query modes: pass tournament_id, season, or player_id, and explains what each scope returns. It also excludes unsupported markets, but it does not explicitly compare against sibling tools or say when not to use this tool versus another odds-related alternative.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so safety needs no restating. The description adds genuinely new behavior: sort direction tied to input shape (ascending for a season, latest-first otherwise) and a cost disclosure ("Costs 1 credit"), which is the kind of billing context annotations cannot convey.

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

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

Front-loaded with the purpose, then filters, then cost — the ordering is sensible and there is little waste. The opening "Use to find tournaments" is mildly redundant with the following sentence but serves as an intent hook.

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

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

An output schema exists, so enumerating return fields is a bonus rather than a necessity, and annotations carry the safety profile. The main completeness gap is league scope — an agent could reasonably read this as golf-only and never discover lpga/liv/dpwt/kornferry from the description.

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

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

Schema description coverage is 100%, so all six params are documented in the schema, making 3 the baseline. The description clarifies season/status/major filtering semantics but says nothing about the league enum (5 values, golf default), limit, or offset paging — the one parameter whose default is least obvious is left entirely to the schema.

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

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

States a clear verb and resource ("Lists a season's tournaments") and enumerates the payload fields (dates, status, purse, major flag, winner, winning score, field size, courses), which separates it from leaderboard/scorecard siblings. It never explicitly names an alternative tool, so sibling differentiation is inferred from the return payload rather than stated.

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

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

"Use to find tournaments" plus "Filter by season, status and major" gives clear conditions for invoking it. There are no explicit exclusions or "use X instead" routing for the overlapping siblings (get_schedule, get_leaderboard), so it stops short of a 5.

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

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

Annotations already establish read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context beyond annotations: the tool costs 1 credit and returns country, tournaments played, wins, and seasons played.

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

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

Three short sentences front-load the primary use case, then summarize the return fields and cost. There is no wasted text, and the most important selection detail appears first.

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 rich annotations, full schema description coverage, and an output schema, the description supplies the remaining selection-critical context: purpose, accent handling, return summary, and cost. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the schema already documents query, limit, and league thoroughly. The description only adds that accents are optional for the name query, which is helpful but limited; the baseline of 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource ('find a player's id by name') and clarifies the lookup is by name with accents optional. This clearly separates it from sibling get_player-style retrieval tools that likely require an id.

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 use case: find a player's id by name. It does not explicitly name an alternative or state when not to use this tool, so it falls short of full when/when-not guidance.

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