CricketStudio MCP

by i-m-arul

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.6.1
Disambiguation5/5
Each tool targets a specific league and entity type, with clearly differentiated purposes. For example, get_bbl_player_profile and get_ipl_player_profile are distinguished by the league prefix, and search tools are league-specific. Overlaps are minimal and intentional (e.g., get_women_cricket_leaders vs get_wpl_leaderboard).
Naming Consistency5/5
All tools follow a consistent verb_noun pattern with league prefixes (e.g., get_bbl_*, list_mlc_*, search_psl_*). Verbs are limited to get, list, and search, making the pattern predictable and easy to navigate.
Tool Count4/5
57 tools is high, but each serves a distinct purpose across 7 different leagues plus cross-league tools. The count is appropriate for the breadth of data covered, though some consolidation could reduce redundancy without sacrificing clarity.
Completeness5/5
The tool surface covers essential CRUD-like operations (profiles, leaderboards, match details, search) for each league, plus cross-league and knowledge graph tools. Dataset summaries and league-specific searches ensure no dead ends. Minor gaps like missing update/delete are expected for a read-only data server.
Average 4.2/5 across 56 of 57 tools scored. Lowest: 3.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 21 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must cover behavioral traits. It mentions returning snapshot data or redirecting to a canonical page for full view. This discloses potential incompleteness and redirection behavior, but 'redirects' is vague (HTTP redirect? JSON link?). More detail on response format or side effects is missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with two clauses, front-loading the purpose. It is reasonably concise but uses a dash that could be replaced with a period for clearer structure. No extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema, the description covers the core intent and fallback behavior. However, it lacks details on the output format (e.g., what fields are returned) and does not clarify that it is IPL 2026-specific (other seasons excluded). Adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (playerSlug) with 0% schema description coverage. The description adds context that the player is from IPL 2026 but does not explain what a slug is or provide format examples. This is insufficient for an agent to correctly construct the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides partnership stats for an IPL 2026 player, listing specific metrics (top stand partners, average runs, most productive wicket-stand). It also mentions a fallback redirect, which adds clarity. Among many player-focused sibling tools, this one distinctly targets partnership data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool vs alternatives like get_player_profile. The description implies it's a summary/snapshot tool but does not help an agent decide between this and similar sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions returning 'available snapshot data' (implying potential partial data) and a canonical URL, but does not detail permissions, rate limits, or what happens if data is missing. The description is adequate but not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, using two sentences to convey the tool's purpose, scope, and output. It is front-loaded with the specific analysis dimensions (pace vs spin, powerplay vs death, dismissal modes), making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one parameter and no output schema, the description provides sufficient context about the tool's input and output (snapshot data or URL). However, it could briefly mention key fields in the snapshot (e.g., dismissal counts) to help the agent determine if the tool meets its needs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter is 'playerSlug', but the description does not explain what a slug is, its format, or how to derive it. With 0% schema description coverage, the description should compensate by providing context, e.g., 'the player's unique slug identifier (e.g., virat-kohli)'. This lack of guidance makes it hard for an agent to correctly invoke the tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: analyzing dismissal patterns for a batter in IPL 2026, broken down by pace vs spin, powerplay vs death, and dismissal modes. It specifically mentions returning snapshot data or a canonical URL, distinguishing it from sibling tools that focus on other leagues or general stats.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what the tool does but does not provide explicit guidance on when to use it versus alternatives. It implies it's for batters in IPL 2026, but lacks clear 'when-to-use' or 'when-not-to-use' instructions, nor does it reference sibling tools like 'get_player_profile' or 'get_season_stats'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description does not disclose behavioral traits such as read-only nature, idempotency, rate limits, or authorization needs. It only describes the output content.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus an example and tip, front-loaded with the main purpose. No unnecessary words; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Explains what the tool returns (profile, claims, sample size, period, provenance) and provides usage guidance. Without an output schema, this is adequate for a simple 1-parameter tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers the single parameter with description. The description adds value by reinforcing the kebab-case format and giving an example, which helps correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns 'Full IPL 2026 player profile + all computed claims across pillars P1–P5'. It names specific verbs and resources, and distinguishes from sibling tools by specifying the league (IPL). However, it does not explicitly contrast with other league-specific player profile tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides example use cases ('How is Bumrah performing?') and a prerequisite instruction ('Use search_players first if you need the slug'). It does not explicitly state when not to use, but the context makes it clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 sample-size floors (30 balls faced, 15 balls bowled) and that it returns a canonical URL. However, it omits details like error handling, rate limits, or whether the operation is read-only, which is implicitly clear but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at four sentences, front-loading the core purpose and providing necessary details without fluff. The topic sentence clearly states the verb and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description does not fully describe the response structure (e.g., player names, stat columns), leaving some ambiguity. It covers aspects, season filter, sample-size floors, and URL, but lacks return field details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds value by enumerating specific aspect examples (e.g., orange-cap, purple-cap) beyond the schema's generic example, and explains context like sample-size floors that affect parameter usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves a BBL leaderboard for a specific aspect across seasons, listing examples like orange-cap and purple-cap. It distinguishes from siblings by specifying the league and aspect scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions calling get_bbl_dataset_summary for the full aspect list, providing a hint for alternative use. However, it lacks explicit guidance on when to use this tool versus other league leaderboard tools (e.g., get_ipl_leaderboard), leaving the decision to the agent's context awareness.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description lacks any behavioral details such as whether the tool is read-only, if results are cached, or what the response format looks like. This is a significant gap for a tool with 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: three sentences that front-load the purpose and provide immediate clarity. No extraneous information, every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given only two simple parameters and no output schema, the description covers the essentials: what each pillar is and how to query for specific insights. It is missing details on the playerSlug format, but overall adequate for such a focused tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description explains the 'pillar' parameter with definitions and examples. The 'playerSlug' parameter is not described, though its purpose is somewhat inferable. The description adds moderate value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns one content pillar for an IPL 2026 player, with specific definitions for P1-P5. This differentiates it from siblings like get_player_profile or get_season_stats, which provide broader information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides direct examples of when to use each pillar (e.g., 'How is Bumrah bowling at the death?' → P3). It does not explicitly state when not to use or list alternatives, but the examples effectively guide usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden for behavioral disclosure. It mentions scope ('Covers all 6 editions in CricketStudio corpus') but does not disclose whether the operation is read-only, any authentication requirements, rate limits, or side effects. This is a significant gap for a tool that likely just fetches data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences plus usage examples) and well-structured. It front-loads the core functionality, provides concrete examples, and explicitly states exclusions. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers the main purpose, inputs, and limitations. It lacks details on the return format (e.g., JSON structure) but the explanation of what is returned (editions, wins, etc.) is sufficient for an AI agent to invoke it correctly. Minor completeness gap due to missing return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single parameter 'teamSlug'. The description examples ('india, australia, england, west-indies') largely mirror the schema description. It adds marginal value beyond the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides national team ICC T20 World Cup record with specific details (editions played, wins, losses, title history, top scorers, canonical URL). It gives example queries that illustrate its purpose and it is distinct from siblings like get_t20wc_leaderboard or get_t20wc_player_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit use cases ('How did India do in T20 WC?', 'Who has won the most T20 World Cups?') and an exclusion ('Does NOT cover women's T20 WC'). However, it does not explicitly compare to alternatives or state when not to use this tool, relying on the sibling list for differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations; description discloses returned data (metadata, URL, splits, strengths) but omits read-only nature, auth requirements, or rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff, front-loaded with action and content, second sentence lists valid inputs efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for simple 1-param tool with no output schema. Specifies record, splits, strengths. Minor gap: no mention of output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers teamSlug with allowed values; description lists the same slugs. No additional semantic meaning beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb 'get' with resource 'team metadata' and explicit content (record, splits, strengths). Distinguishes from siblings by specifying 'IPL 2026'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when/when-not guidance or alternatives among many sibling tools. Implied usage for IPL team profiles.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description carries full burden. It declares a list of trends with filtering and return fields, but does not mention ordering, pagination, or whether 'all' is comprehensive. Sufficient for a simple read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One concise sentence front-loading the main purpose and covering key details without extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description specifies return fields. All parameters are documented. Missing details like sorting or whether limit applies per kind, but overall sufficient for an agent to use the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both parameters. The description adds context by listing valid kind values and stating default/max for limit, but this is also in schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists all IPL 2026 cross-fixture trends with optional kind filtering and specifies return fields. It distinguishes from sibling tools that focus on players, teams, or matches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when trends are needed, but lacks explicit guidance on when to use this tool versus alternatives like get_trend. No comparison or exclusion criteria provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. Discloses return of a canonical URL but does not mention output format, side effects, or safety. Adequate but not detailed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured, starting with purpose then aspects, usage, and return. The list of 46 aspects is informative but slightly verbose. Could be trimmed without losing value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity and lack of output schema, the description covers the main functionality, data source, and parameter usage. Missing only details on output format or API behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. Description adds value by listing many aspects and providing a concrete season example, plus limit defaults. Enhances understanding beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides an IPL historical leaderboard from a specific corpus, listing 46 aspects. It distinguishes from sibling tools by mentioning 'IPL' and the data source.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Describes how to scope by season with an example, but does not compare to siblings like get_bbl_leaderboard or get_cross_league_leaders. Lacks explicit guidance on when to use this vs alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It reveals important constraints: sample-size floors (≥30 balls for strike rate, ≥15 balls bowled for economy), which directly affect result reliability. It also identifies the data source as 'canonical aggregate'. This goes beyond what structured fields alone convey, but still omits details like data freshness, pagination, or read-only nature.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences that front-load the main purpose and immediately list key options and constraints. Every sentence adds information without redundancy, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 3 parameters and no output schema. The description covers the primary purpose, sortable metrics, and sample-size floors. However, it fails to describe the structure of the returned data (e.g., player names, numerical aggregates) or how results are ordered. Given no output schema, this omission leaves the agent uncertain about what to expect, making the description incomplete for a leaderboard tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 67% of parameters with descriptions (limit and teamCode). The description adds value by listing the sortBy options (though the schema already has an enum) and attaching the sample-size floors to specific metrics. However, it does not explain limit's default/max in any new way beyond the schema. Overall, the description supplements but does not significantly transform parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool provides an 'IPL 2026 season leaderboard from CricketStudio canonical aggregate', clearly specifying the verb (get/retrieve), resource (season leaderboard), and scope (IPL 2026). It lists sortable metrics and optional filters, which distinguishes it from sibling tools like get_ipl_leaderboard (which may be for different seasons or broader).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving season stats with specific sort options and a team filter, but it does not explicitly state when to choose this tool over similar siblings like get_ipl_leaderboard or get_bbl_leaderboard. The mention of sample-size floors provides some context for data reliability, but no direct guidance on use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description adds behavioral context like sample-size floors and edition coverage, but does not disclose authentication, rate limits, or whether it is read-only.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with purpose, and every sentence contributes meaningful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description mentions return of a canonical URL but does not detail the full response structure (e.g., ranking, player stats). For a leaderboard tool, this lack of output specification is a gap, though sample-size floors and edition coverage are helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds value by listing example aspect values (orange-cap, purple-cap) and noting the default limit. However, the schema already describes the parameter meaning adequately.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it's the cross-edition ICC T20 World Cup leaderboard for one aspect, lists specific aspects (orange-cap, purple-cap), and covers all 6 editions, distinguishing it from sibling tools for other leagues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for T20WC leaderboards via context of sibling tools, but it does not explicitly state when to use this tool versus others or provide exclusion criteria like 'use get_ipl_leaderboard for IPL'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only status, data freshness, permissions, or rate limits. The word 'recap' implies a finished match, but this is not explicitly stated as a constraint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with front-loaded core information. No redundant words; every sentence adds value, including usage examples and cross-reference to list_fixtures.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple input (one param) and no output schema, the description sufficiently explains what to expect (performers, highlights, milestones). However, it does not specify the return format (text vs structured data), which might be needed for optimal agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter 'matchId' is not described in the schema (0% coverage), but the description adds meaning by explaining its purpose (identifying a match) and how to discover valid IDs via list_fixtures. An example ('match 69635') is given, though format specifics are lacking.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool provides key performers and highlights for a single finished IPL 2026 match, with specific examples like 'top batter, top bowler, MOTM, milestones'. It distinguishes from siblings by specifying it's for finished matches and includes concrete use-case queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides use-case examples ('Who won the MI vs RCB match?') and guidance on how to obtain the required parameter ('Use list_fixtures to discover matchIds'). However, it does not mention when not to use this tool versus alternatives like get_match_state.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that sample-size floors are enforced (results may be suppressed), and provides a permanent citable URL, which indicates idempotency and caching potential. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two sentences, each adding valuable information: the tool's output and key details (kinds, URL, sample-size enforcement). No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of output schema and annotations, the description adequately covers the tool's purpose and constraints. However, it could briefly describe the structure of a claim card to improve completeness for agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description lists the kind enum values explicitly, compensating for 0% schema description coverage. However, matchId is not described, leaving its purpose implicit. The schema's enum is conveyed, but additional details (e.g., format of matchId) are missing.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states this tool retrieves a single atomic claim card from an MLC match, enumerates the specific kinds (top-batter, top-bowler, biggest-partnership, pp-control, death-domination), and distinguishes it from sibling tools like list_atomic_claims (which likely returns multiple claims) and get_mlc_match (full match summary).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a specific claim card is needed but does not explicitly state when to use versus alternatives (e.g., list_atomic_claims for multiple claims). No when-not or exclusion criteria are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses a sample-size floor (≥5 deliveries) and return data fields, effectively communicating read-only behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tightly packed sentences with no filler, front-loading the core function (batter vs bowler H2H in IPL 2026) followed by key constraints and outputs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Lists all return fields and the sample-size floor, fitting for a specific stat tool. Lacks explanation of 'canonical URL' but overall adequate given no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage; description adds format constraint ('kebab-case') and identifies both parameters as slugs, partially compensating but not explaining how to obtain slug values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns batter-vs-bowler head-to-head records specifically for IPL 2026, distinguishing it from other player-related tools among siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the description implies usage for H2H records, it lacks explicit guidance on when to use this tool versus alternatives like get_player_profile or other league-specific tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses return fields (bigStat, hook, supporting numbers) but lacks details on side effects, auth requirements, or rate limits. Basic transparency for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with the main action, no wasted words. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, description adequately explains return structure. For a simple 1-param tool, it covers purpose, return fields, and ID discovery. Could mention cross-fixture nature more explicitly but sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (trendId) with 0% schema coverage. Description adds that the ID is 'stable' and how to discover it via list_trends, providing essential context beyond the schema structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves a single trend insight by stable ID and lists its contents (bigStat, hook, supporting numbers). It also explicitly distinguishes from list_trends (which discovers IDs), providing a specific verb-resource pair.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Description advises using list_trends to discover IDs, indicating when to use this alternative. However, it does not elaborate on when not to use this tool or other contextual exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, but description discloses return fields and optional filters. Lacks details on pagination or other behaviors, but adequate for a list tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with key info, no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers essential aspects: what, how to filter, and usage context. Missing output schema but return fields listed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters with descriptions; description adds minimal extra (e.g., 'optional status/team filter') but essentially redundant.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists all 74 IPL 2026 fixtures with optional filters, and distinguishes from sibling tools by specifying the league and purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly tells agent to use this tool to discover matchIds for get_match_state and get_match_recap, providing context, though not specifying when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses that it does substring matching and gives an example slug format. Lacks details on potential side effects, rate limits, or authentication, but for a search tool the behavior is adequately transparent given the context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences that are front-loaded with the primary action. Every sentence adds value: first defines the tool's purpose, second provides a concrete example and use context. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with 2 parameters and no output schema, the description covers the key usage: how to search (substring), what to search (name/slug), and the follow-up tool. The addition of the Cricksheet initials format is helpful. Minor gap: does not mention what the slugs are used for beyond the next tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 2 parameters with 50% description coverage. The description adds meaning to the 'query' parameter by explaining it does substring matching against name or slug, but does not specify the expected format beyond the example. The 'limit' parameter is already described in schema. With partial coverage, the description partially compensates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the verb 'Find', the resource 'MLC player slugs', and the method 'substring match against name or slug'. Distinguishes from sibling tools by specificity to MLC and the example conversion from 'F du Plessis' to 'f-du-plessis'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use before get_mlc_player_profile', indicating when to invoke this tool. Also provides a formatting hint for Cricsheet initials. However, does not explicitly state when not to use it or mention alternatives, though sibling names imply it's the MLC-specific search.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It states case-insensitive substring matching and the fields returned, but does not mention behavior on empty results, pagination, or rate limits. It adequately covers the read-like nature of the operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero waste. Every word adds value: it specifies the league, the search criteria, case-insensitivity, the returned fields, and usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity and the presence of sibling tools, the description is mostly complete. It states the purpose, parameters, and return fields. It could mention behavior on no matching results, but overall it is sufficient for an agent to understand and use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema; the 'substring match' is already in the query parameter description, and the limit parameter's default and max are in the schema. No extra value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: finding IPL 2026 player slugs by substring match against name, slug, or team. It specifies the league (IPL 2026) and the returned fields (slug, fullName, team, role), distinguishing it from sibling tools for other leagues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises using this tool before get_player_profile when only a name is known, providing clear contextual guidance. It implicitly suggests not using it when a slug is already known, but does not exclude other use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool 'gracefully omits leagues where snapshot data is unavailable' and returns 'ranked rows with league context per player'. It also lists supported metrics. This covers key behavioral aspects beyond the input schema. A score of 4 reflects good transparency without contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph of 4 sentences, front-loading purpose and examples. It is concise and avoids unnecessary detail. While it could be broken into bullet points for easier scanning, the current structure is clear and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters and no output schema, the description is reasonably complete. It covers purpose, usage examples, return format (ranked rows with league context), supported metrics, and behavior for missing data. It lacks details like ranking order or thresholds, but overall provides sufficient context for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description reinforces the enum values ('runs, wickets, sixes, fours, economy') but adds no extra meaning beyond what the schema already provides (default limit, enum). Therefore, the description does not significantly enhance parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: ranking top performers by a metric across all 7 CricketStudio leagues. It uses specific verbs ('top performers', 'returns ranked rows') and identifies the resource ('cross-league leaders'). It distinguishes from sibling tools like get_ipl_leaderboard by explicitly mentioning 'across all 7 CricketStudio leagues' and giving cross-league query examples.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage examples ('who is the most prolific T20 run scorer across all leagues?') and mentions graceful omission of unavailable data. While it doesn't explicitly state when not to use or list alternatives, the examples imply single-league queries should use league-specific leaderboards. This is sufficient for guiding an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 reveals that the tool returns seasons, match count, and hub URL, and lists valid inputs. However, it does not disclose that this is a read-only operation, nor does it discuss rate limits, permissions, or side effects. The description is adequate but minimal beyond the listed valid values.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the tool's scope, valid inputs, and outputs without any filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description covers the essential context: valid inputs and high-level output. It could be improved by specifying the return format (e.g., array of seasons) or that it returns all seasons, but it is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description fully compensates by listing all 6 valid team slugs, adding crucial semantic meaning to the bare 'teamSlug' string parameter. This prevents guesswork and errors.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly names the tool as one of 6 MLC franchises and lists the valid team slugs, clearly distinguishing it from other team profile tools for different leagues (e.g., get_bbl_team_profile, get_psl_team_profile). It also states the return values: seasons, match count, and hub URL.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives like get_team_profile or sibling tools for other leagues. The list of valid slugs implies it's for MLC teams, but no direct guidance on choice or exclusion is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description discloses that results are aggregate counts, not ball-by-ball data, and that not every opponent appears because the set mirrors the head-to-head pair set. This is sufficient behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is three sentences, front-loading the core purpose. Each sentence adds value: purpose, use cases, and behavioral nuance. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately explains return structure (franchise, bowlers, dismissers, canonical URLs, aggregate counts) and scope (mirrors head-to-head set). Context is sufficient for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both parameters have descriptions). The description does not add new meaning to the parameters beyond what the schema provides, meeting the baseline for high coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it returns a player's graph neighborhood including franchise, most-faced bowlers, and top dismissers, with canonical URLs and aggregate counts. Distinguishes from get_player_h2h by noting that matchup edges mirror that tool's pair set, preventing confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides concrete example queries ('who are Kohli's toughest bowlers', 'which team does Kohli play for') and clarifies returns are aggregates not ball-by-ball. Implicitly differentiates from get_player_h2h but does not explicitly state when to use one over the other.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses sample-size floors (≥30 balls faced, ≥15 balls bowled) which is good. However, it doesn't mention response format, pagination, or error handling. The schema's limit description (default 20, max 100) is sufficient, but the description adds no further behavioral context beyond the sample floor.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no wasted words. First sentence gives purpose and examples; second sentence provides usage hint and constraint. Information is front-loaded and efficiently presented.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters, no output schema, and no annotations, the description covers the core purpose and constraints (sample-size floors) but lacks details about the return value. For an agent, knowing what the response looks like (list of players with stats) would be beneficial. Points to another tool for aspect list, which helps completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by clarifying the scope (one aspect, filter by season) and mentioning the sample-size floor, which relates to the aspect parameter. This provides meaningful context beyond the schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it's for WPL leaderboard for one aspect across all or filtered season. Lists example aspects (orange-cap, purple-cap, etc.), which distinguishes it from other league-specific leaderboards. The naming aligns with sibling tools like get_ipl_leaderboard, making it clear when to select this tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit context: call get_wpl_dataset_summary for the full aspect list, and mentions sample-size floors. However, it does not explicitly state when not to use this tool versus alternatives like compare_players or other league leaderboards. The league-specific naming helps but lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavioral traits. It describes return fields and optional filters but does not explicitly state that the operation is read-only, safe, or non-destructive. The listing nature implies safety, but without annotations, more explicit transparency would be beneficial.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first states functionality and optional filters, second states return fields and purpose. No redundant information; every sentence serves a clear purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 optional params, no output schema) and context of sibling tools, the description is complete. It lists all key return fields, explains optional filters, and specifies the use case for discovering matchIds. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67% (limit and season described; teamSlug missing). Description adds context that filters are optional and list the return fields, but does not elaborate on teamSlug format. It adds moderate value beyond the schema, compensating somewhat for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb 'List', resource 'MLC matches', and optional filters (season, team slug). It also mentions return fields and a specific use case (discovering matchIds for get_mlc_match), distinguishing it from siblings like get_mlc_match.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Use to discover matchIds for get_mlc_match.' Provides clear context but does not explicitly mention when not to use or alternative tools; however, the purpose is sufficiently differentiated from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description shoulders the full burden. It discloses substring match, case-insensitivity, editions count, and example slug transformation. However, it does not specify the output format (e.g., list of slugs or full objects), pagination behavior, or what happens on no match, leaving behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no extraneous content. It starts with purpose, provides context, and ends with usage instruction and exclusion. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema and annotations, the description should cover both input and output behavior. It handles input well (case-insensitive substring, editions) but omits output structure (what is returned: slug only? multiple matches? empty result handling). This incomplete coverage lowers the score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for 'query' and 'limit'. The tool description adds no additional parameter meaning beyond the schema (e.g., provides example but does not elaborate on format constraints). Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it finds player slugs for ICC Men's T20 World Cup by substring match, with a specific example. It distinguishes itself from siblings like search_wpl_players and search_players by explicitly noting it is not for WPL players and specifying the tournament scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells the agent to use this tool before get_t20wc_player_profile, and explicitly states it is NOT for WPL players. This provides clear when-to-use and when-not-to-use guidance, with implied alternatives for other player searches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It mentions data source ('CricketStudio canonical snapshot') and included stats, but lacks details on return format, pagination, or any other behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first states what the tool does, second explains parameter usage. No unnecessary words; information is front-loaded and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with 2 optional parameters and no output schema, the description adequately covers purpose, data included, and usage pattern. Minor gaps on sorting or pagination, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds value by explaining the conditional behavior of playerSlug (omit for leaderboard). This enriches beyond the schema's static descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it retrieves IPL 2026 fielding stats (catches, run-out assists, total dismissals) and distinguishes from siblings like get_ipl_leaderboard or get_player_profile by focusing specifically on fielding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Clear guidance on using playerSlug for individual stats or omitting for leaderboard. No explicit mention of when to use over alternatives, but the specificity implies the context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It mentions returning a per-league stats block with canonicalUrl and gracefully omitting missing leagues. This is adequate but doesn't detail auth, rate limits, or performance.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and examples, then usage guidance. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one param and no output schema. The description covers what is returned (per-league stats block, canonicalUrl) and behavior (omits missing leagues). Slight lack of detail on stats format, but sufficient for selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one parameter, playerSlug. The description adds value by explaining the slug format and suggesting to use search_players first, which goes beyond the schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves a player's statistics across multiple CricketStudio leagues in one call, listing specific leagues (IPL, MLC, WPL, etc.). This distinguishes it from per-league sibling tools like get_bbl_player_profile or get_player_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Use for players who appear in multiple leagues' and provides examples. It lacks explicit when-not-to-use instructions, but the sibling tools for individual leagues imply the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 tool returns metadata and a URL, and imposes a sample-size constraint. However, it does not mention whether the operation is read-only, any authentication requirements, or rate limits. Given the lack of annotations, the description adds moderate value but lacks full behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences that pack in the purpose, content examples, a usage constraint, and a pointer to another tool. Every sentence earns its place, and the most important information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no annotations, no output schema), the description provides sufficient context: it lists the kind of data returned, a usage constraint, and how to get the required slug. It could be slightly more explicit about the output format or whether the metadata is structured, but it is adequate for an agent to make an informed decision.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one parameter 'venueSlug' with 0% description coverage. The description adds meaningful context by stating 'Use list_fixtures to find venue slugs', informing the agent how to obtain valid parameter values. This goes beyond the schema and compensates well for the lack of schema-level parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Venue metadata + canonical URL for the full hub page' and lists specific content like par 1st-innings score, toss-decision split, etc. This makes the purpose unambiguous and distinguishes it from siblings, especially since no other venue-specific tool exists.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions a 'Sample-size floor: ≥3 fixtures', which tells the agent the tool requires data from at least 3 fixtures to provide meaningful results. It also directs users to 'Use list_fixtures to find venue slugs', offering practical guidance. However, it does not explicitly state when to avoid using this tool or list alternative tools for different needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses returned data types and Cricsheet attribution, and implies read-only nature. However, does not mention authentication or rate limits, and 'leaderboard aspects' is vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with key purpose ('First call for WPL coverage'), no wasted words. Efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description lists main return components (seasons, counts, leaderboard, attribution) and usage instructions. Tool has no parameters, so content is sufficient. Minor gap: doesn't specify if output is a single object or list, but inferred as summary object.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, schema coverage 100% (trivially). Baseline 4 applies; description adds no parameter info, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Describes specific verb 'returns' for WPL dataset summary, lists contents (seasons, counts, leaderboard, attribution). Distinguishes from siblings by stating 'Use before other get_wpl_* tools' and explicitly excluding other women's competitions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
States 'First call for WPL coverage' and 'Use before other get_wpl_* tools', providing clear context. Also notes what it does NOT cover (WBBL, CPL Women, etc.), helping agent avoid misuse. Does not explicitly name alternative tools for other leagues but negation suffices.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full responsibility. It clearly states what data is returned and what is excluded. However, it does not mention error handling (e.g., invalid slug), idempotency, or side effects. The transparency is high for a read operation but not complete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with purpose, and contains no superfluous information. Every sentence adds value: specifying return fields, listing slugs, and clarifying scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description compensates by detailing the return fields. The tool is simple with one parameter, and the description provides sufficient context for an agent to understand inputs and outputs without gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the schema already describes 'teamSlug' as 'PSL franchise slug e.g. karachi-kings, lahore-qalandars'. The description adds the list of slugs but does not significantly enhance the schema's semantics; thus baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool 'Returns franchise name, seasons played, match count, and canonical URL' for 'One of the PSL franchises'. It clearly distinguishes itself from siblings by flagging it does NOT return BBL/IPL data, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage from the context of PSL franchises and lists valid slugs. It excludes BBL/IPL but does not explicitly guide when to use this tool over other profile tools like get_team_profile or compare_players. The guidance is good but lacks explicit alternatives or conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full burden. Discloses 'Sample-size floors enforced' as a behavioral trait. Lists many aspects to show breadth, but does not mention read-only nature or any permission requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with key purpose and then illustrates breadth with many examples. Examples are relevant but could be trimmed; still efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema, but description covers purpose, parameter defaults, and behavioral constraint (sample-size floors). Missing return format details, but for a simple list tool this is adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds value by specifying default (20) and max (100) for limit, and provides concrete examples for aspect like 'orange-cap'. This goes beyond the schema's generic description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Top-N rows of one MLC leaderboard aspect' with specific verb 'list' and resource 'leaderboard aspects'. It lists 55 example aspects, distinguishing it from sibling tools that focus on other leagues or general summaries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly recommends 'Call get_mlc_dataset_summary for the full list' and mentions 'Sample-size floors enforced'. Provides context on when to use (single aspect, top-N) but lacks explicit exclusion of multiple aspects or comparison to other leaderboard tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the return format (list of entities with canonical URLs or connected=false) and the depth limit (≤4 hops). No annotations are provided, so the description covers the essential behavioral traits. It could mention that it is read-only, but overall transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences plus an example. It is front-loaded with the core functionality and example, and every sentence adds value. No fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with three parameters and no output schema, the description covers purpose, input examples, depth limit, and return format. It is complete enough for an agent to use correctly, though it could explicitly state default maxDepth (3) as per schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by explaining the concept of 'shortest connection' and mentioning the example of a shared franchise, which enriches the understanding of the parameters and their usage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool finds the shortest connection (≤4 hops) between two cricket entities. The example 'how is Kohli connected to Bumrah' makes it concrete and distinguishes it from siblings like get_player_connections which might have different logic or depth.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a clear use case for the tool (how is X connected to Y). However, it does not explicitly contrast with alternative tools or state when not to use it. The example helps, but exclusion criteria are missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It describes what the tool returns (seasons, stats, URLs, attribution) which is transparent for a read-only dataset summary. No mention of destructive actions, but none expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first states purpose and output, second clarifies league distinction and path. No fluff, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 output schema, the description sufficiently covers what is returned: seasons, stats, URLs, attribution. It could mention data format or error handling, but it's adequate for agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist (0 params), so baseline is 4. The description adds meaning by detailing the output content beyond what an empty input schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'returns' and the resource 'dataset summary' for MLC, listing specific outputs like seasons, stats, URLs, and attribution. It distinguishes from siblings by noting MLC is distinct from IPL and under /leagues/mlc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'First call for Major League Cricket (MLC) coverage', providing context for when to use it. However, it does not explicitly state when not to use or directly compare to alternatives like get_dataset_summary.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description explains the tool returns detailed match information and lists all included elements. It is a read operation, and no side effects are implied; however, it lacks details on output format or potential limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first efficiently lists the tool's output, the second explains the input parameter. No fluff, front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a match detail tool with no output schema, the description provides a comprehensive list of returned data and explains the input. Could mention output structure more, but sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description adds crucial context: matchId is a Cricksheet ID with an example. This compensates for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'get' and resource 'MLC match', lists specific contents (teams, venue, toss, result, etc.), and distinguishes from sibling tool list_mlc_matches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using list_mlc_matches to discover ids, providing an alternative for when the id is unknown. Does not explicitly state when not to use, but the guidance is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 sample-size floors (≥30 balls faced, ≥15 balls bowled) and that it returns a canonical URL. This is appropriate for a read-only query, though it could mention if any destructive behavior is absent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences. The first sentence front-loads the primary purpose (leaderboard for an aspect), followed by details on aspects, sample-size floors, and canonical URL. Every sentence is necessary and no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description mentions the canonical URL but does not describe the return structure (e.g., list of players with stats). For a leaderboard, an agent might expect ranking information. However, the aspect list and sample-size floors provide useful context. It is mostly complete but could clarify output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters, baseline 3. The description adds value by explaining the aspect parameter with examples, mentioning default limit (20) and max (100), and noting that season is optional. This goes beyond the schema's brief descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns a PSL leaderboard for a given aspect across all seasons or a filtered season, with specific examples like orange-cap and purple-cap. It distinguishes from sibling tools by specifying PSL-specific context and referencing get_psl_dataset_summary for the full aspect list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description advises users to call get_psl_dataset_summary for the full aspect list, which provides clear guidance on when to use this tool vs that one. However, it does not explicitly state when not to use this tool or compare it to sibling tools like get_bbl_leaderboard.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the output: career batting and bowling aggregates across all seasons with phase splits. Since no annotations are provided, the description carries the full burden and adequately discloses the tool's behavior as a read operation returning structured stats.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each serving a clear purpose: purpose, league specification, and usage guidance. No unnecessary words, and critical information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description covers what it returns (batting+bowling aggregates, phase splits) and how to use it. It could be more detailed about the exact structure of the output, but it is sufficiently complete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema describes playerSlug as a kebab-case PSL player slug with an example. The description reinforces this and adds context on how to obtain the slug (via search). Schema coverage is 100%, and the description adds value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves a PSL player's career batting and bowling aggregates with phase splits, and specifies the league (Pakistan Super League only). This distinguishes it from sibling tools like get_player_profile (likely all leagues) or get_wpl_player_profile (WPL).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use search_psl_players first if the slug is unknown, providing clear guidance on when to use this tool vs. a search tool. However, it does not explicitly state when not to use it compared to other player profile tools, though the league specificity implies context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses return value ('related entities + canonical URLs') and what it excludes (per-ball detail), but does not explicitly state that the operation is read-only or safe to call repeatedly. Since no annotations are provided, this omission leaves ambiguity about behavioral traits like side effects or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single paragraph of three sentences, front-loaded with core purpose and examples, followed by parameter details and exclusions. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description covers purpose, parameters, usage, and exclusions adequately. It could mention whether results are paginated or if limit is exact, but for a graph traversal tool the information is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%, so baseline is 3. The description adds context by explaining that `slug` identifies the entity, `predicate` filters edge types (listing the three values), and `direction` controls traversal direction. It also explains `limit` default and max. This compensates for missing schema descriptions for `direction` and `predicate`.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs 'knowledge-graph traversal' to find entities connected to a player or franchise, with concrete examples like 'who does Kohli play for'. It distinguishes itself from get_player_h2h by explicitly noting that tool is for per-ball detail.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage guidance: examples of queries it answers, and a clear when-not-to-use instruction: 'Does NOT return per-ball detail — use get_player_h2h for one matchup.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description discloses key behavioral traits: key findings are atomic claims with sample-size provenance, and the canonical URL contains the full dataset. It does not mention side effects or auth requirements, but for a read-only retrieval tool, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that front-load the purpose and return fields, then provide usage guidance and output details. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers the returned fields, data structure, and how to get valid IDs. Missing error handling details, but overall complete enough for agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers the parameter reportId with examples (100% coverage). The description adds value by referencing list_research_reports for discovery, providing additional context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states that the tool retrieves full details for a research report by ID, listing specific fields (title, series, summary, etc.) and distinguishes from sibling tools like list_research_reports.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using list_research_reports to discover valid IDs, providing clear context for when to use this tool. Does not explicitly state when not to use, but the guidance is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Describes return values (matches, wins, no-results, recent meetings, atomic lead claim, canonical URL) but does not mention side effects or access requirements, which are expectedly minimal for a query tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no redundancy. Front-loaded with purpose, then details on parameters and output. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple query tool with two parameters and no output schema, the description adequately covers input format and return summary. Could add more on handling invalid slugs or multiple seasons, but sufficient for typical usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but description compensates by listing example slugs and stating order doesn't matter. Clarifies that parameters accept team identifiers like 'mi', 'csk', etc., adding meaning beyond the bare type 'string'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns team-vs-team head-to-head record across IPL 2026, with specific metrics and output. It distinguishes from siblings like compare_players and player_h2h by focusing on team comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage guidance: pass slugs in any order with a list of examples. Does not explicitly state when not to use, but the context suggests it's for team head-to-head queries, differentiated from player comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that results include provenance, sample size, and canonicalUrl, and that the corpus is the full IPL 2026 set. No annotations provided, so description carries burden. Does not mention pagination or ordering, but overall transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. First sentence states purpose and return type, second gives examples and filter options. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers filterable fields, example queries, and result characteristics. Could mention default limit or sorting order. No output schema, so description partially compensates but could be richer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 75% (3 of 4 params described). Description adds value by clarifying filter criteria ('team code or name', 'player name or slug') and providing examples that illustrate usage of pillar and player. Limit param not mentioned in description but schema covers it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs filtered queries across atomic claims, specifies the resource (IPL 2026 atomic-claim corpus), and provides concrete example questions. It distinguishes itself from sibling tools like get_ipl_leaderboard (aggregate stats) and get_player_profile (player details).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states filter options (player name, team code, pillar) and provides example queries, implying when to use. Lacks explicit when-not-to-use guidance, but the context and sibling tool names make it clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. Discloses returned fields and organization into Series 1 and Series 2 (with example report slugs). Sufficient for a read-only list operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first sentence states purpose and output, second provides usage guidance and organization context. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers purpose, return fields, usage context, and series organization. Lacks pagination or limit info but is adequate for a simple list tool with one optional parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with description for the series parameter. Description adds extra semantics by listing the series values (ipl, mlc) and the report organization behind them.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool lists all published CricketStudio research reports with specific fields (id, title, series, summary, status, canonicalUrl). Distinguishes from sibling get_research_report by mentioning it's for discovery before that call.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use to discover available reports before calling get_research_report', providing clear context. Does not specify when not to use, but purpose is well-defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations, so description must bear burden. It mentions dataset size and seasons but does not disclose return format, error behavior, or idempotency. Implies read-only but not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus example and note. Front-loaded with key info. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given many sibling player search tools, description clearly delimits league scope. Provides pre-requisite context. Could mention pagination or output format but is sufficient for its purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%. Description adds value for 'query' parameter with example and explanation of substring matching. For 'limit', it adds no new detail beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states tool finds BBL player slugs by substring match against full name or slug. Provides example and specifies league. Distinguishes from siblings by explicitly noting 'BBL only' and 'NOT for PSL/IPL/MLC players'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use before get_bbl_player_profile' and 'NOT for PSL/IPL/MLC players', giving clear context for when to use and when not to, with an alternative path.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It transparently lists the returned data (seasons, counts, leaderboard aspects, attribution) and clarifies the scope (men's BBL only). While it lacks details on rate limits or response structure, the behavior is simple and sufficiently disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose and key details, and includes usage guidance. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no params, no output schema), the description fully covers what the tool returns, when to use it, and its scope. It is complete for an agent to decide when to invoke this tool among many siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline is 4. The description does not need to add parameter information since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a summary for BBL coverage, listing specific data points (seasons, match count, team/player counts, leaderboard aspects, attribution). It distinguishes itself from siblings by noting it is the 'first call for BBL coverage' and explicitly excludes WBBL.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use before other get_bbl_* tools,' providing clear context for when to call it. It also notes it covers only men's BBL, implying not for WBBL, though no explicit alternative is mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description sufficiently discloses the return content (corpus counts, URLs, non-negotiables, license) and the tool's role as an informational starting point. No destructive behavior is implied, and the description is transparent about what the tool provides.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (2 sentences) with front-loaded purpose ('First call'). Every sentence adds value, listing specific content and usage guidance without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and low complexity, the description fully specifies what the tool returns (leagues, counts, URLs, non-negotiables, license) and its role in the workflow. Nothing is missing for an introductory catalog tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the description's job is trivial. Schema coverage is 100%, and the description adds context about the output instead of parameters, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns CricketStudio's coverage (leagues, counts, URLs, non-negotiables, license) and positions it as the 'first call' to ground subsequent queries. It distinguishes from sibling tools that focus on specific leagues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'First call' and 'Use to ground subsequent queries', providing clear context for when to use. However, it does not explicitly state when not to use or list alternatives, but the sibling tools imply specific use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It transparently lists returned data and attribution requirement. Could be improved by mentioning any side effects or performance, but none are expected for a read-only summary.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-loading purpose and usage. Every word adds value; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and no output schema, description fully covers the tool's purpose, content, and attribution requirement. Complete for a summary tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters, schema coverage 100%. Description adds meaning by detailing what the summary includes, which is the only needed information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it is the first call for PSL coverage, lists specific data (seasons, match count, etc.), and distinguishes from sibling tools with 'Use before other get_psl_* tools.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises using before other get_psl_* tools, providing clear context. Lacks explicit when-not-to-use or alternatives, but the guidance is strong and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the return fields and valid slugs, which is adequate for a read-only lookup tool. It does not mention rate limits or authentication, but that is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, front-loaded with purpose, and contains no redundant information. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the single parameter and no output schema, the description sufficiently explains what the tool does, what data it returns, and valid inputs. No gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the description adds value by listing valid slugs and explaining the return data, making the parameter more meaningful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns WPL franchise data, including specific fields like top batters and bowlers, and lists valid slugs. It distinguishes from siblings by explicitly saying it does not return IPL men's team data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explains the tool is for WPL franchise data and clarifies it does not return IPL men's team data, but does not explicitly provide alternatives or when not to use it. However, the context is clear due to sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Discloses that the tool returns a canonical URL and lists the comparison fields. It could mention idempotency or potential restrictions, but the behavior is clearly non-destructive and well explained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences. First covers purpose and content, second provides guidance and return value. Every sentence is necessary, no redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description covers the key return aspects (comparison fields, canonical URL). It identifies the specific league and year, which is sufficient for the agent to understand the tool's scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema description coverage, the description adds meaning by explaining that 'slugs' are player identifiers and directs to search_players for resolution. This adds context beyond the schema's raw type definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'comparison' and the resource 'IPL 2026 players', specifying the exact fields compared (team, role, claim count per pillar, headline claim). It distinguishes from siblings like 'get_player_profile' by focusing on side-by-side comparisons of multiple players.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: for comparing 2-8 IPL 2026 players. Provides a prerequisite: 'Use search_players to resolve slugs first.' This guides the agent to the appropriate sibling tool and prevents misuse.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description discloses data scope (career aggregates with phase splits), league restriction, and slug format; lacks mention of permissions or rate limits but adequate for a read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences each serve a distinct purpose: tool output, league/slug details, usage guidance. No redundant text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given single parameter and no output schema, description provides sufficient context for selection and invocation; could include output format but not critical for basic usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers parameter, but description adds value by specifying kebab-case format with an example, aiding correct parameter construction beyond schema definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description specifies the tool retrieves a BBL player's career batting and bowling aggregates with phase splits, clearly distinguishing it from league-specific siblings like get_ipl_player_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises to use search_bbl_players when slug is unknown, and warns not to use for WBBL, providing clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. Lists return fields and valid slugs. Implicitly read-only (profile retrieval), but does not explicitly state lack of side effects or permissions needed. Sufficient for a simple data retrieval tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus a list. Front-loaded with purpose. Every word adds value. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, description fully defines return fields and acceptable inputs. Includes exclusion of non-BBL data. Adequate for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% but description adds full list of valid team slugs, which is far more informative than schema examples. Also explains what returns (name, seasons, match count, canonical URL) providing context beyond parameter description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it returns BBL franchise profile with specific fields (name, seasons, match count, URL). Distinguishes from sibling functions like get_team_profile (general) and other league-specific profiles by explicitly scoping to BBL and noting it does not return IPL/PSL data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Specifies it is for BBL franchises and explicitly excludes IPL/PSL. However, no direct comparison with other sibling functions like get_team_profile or advice on when to choose this over alternatives; still clear enough for an agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It accurately states it returns summary data and is read-only. However, it does not mention response format or any potential rate limits, which is acceptable given the simplicity. A score of 4 is appropriate for a clear but not exhaustive disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no wasted words. The first sentence provides purpose and return details; the second adds usage guidance and scope. Efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters, no output schema, and straightforward behavior, the description is adequate. It explains what it returns, scope, and usage order. It could briefly mention why to use it (e.g., to get dataset context), but overall it's complete enough for the task.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist (input schema is empty), and schema coverage is 100%. Baseline for zero parameters is 4. The description adds context about the return values, which is valuable beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it is the first call for ICC T20 World Cup coverage, specifying the exact data returned (editions, counts, leaderboard aspects, attribution). It distinguishes from siblings by explicitly mentioning the scope (men's ICC T20 World Cup only) and directing to other get_t20wc_* tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use before other get_t20wc_* tools' and clarifies that it covers only men's ICC T20 World Cup, not bilateral series or women's WC. This provides clear when-to-use and when-not-to-use guidance, fulfilling the guidelines dimension well.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 scope (Men's T20 WC only) and what data is returned (batting/bowling aggregates, per-edition, phase splits). While it doesn't mention read-only or auth requirements, the context implies a safe retrieval operation. The description adds value beyond annotations (which are absent).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: the first explains what the tool returns, the second provides parameter format and usage guidance. No redundant information; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description is adequate. It covers purpose, parameter usage, and scope restrictions. Minor omission: no mention of error behavior for invalid slugs, but not critical for completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter (playerSlug) has schema description 'Kebab-case T20 WC player slug e.g. v-kohli'. The description reinforces this format and adds the suggestion to use search_t20wc_players first. Schema coverage is 100%, so baseline is 3; the added usage advice justifies a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool retrieves a player's ICC Men's T20 World Cup career profile, including batting and bowling aggregates, per-edition breakdown, and phase splits. It specifies the resource (player profile), scope (T20 WC), and differentiates from sibling tools like get_player_profile or get_wpl_player_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use a kebab-case slug (e.g., 'v-kohli'), recommends using search_t20wc_players first if the slug is unknown, and warns against mixing with WPL. This provides clear when-to-use and when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description mentions 'sample-size floors enforced' as a behavioral constraint and implies read-only nature. With no annotations, it provides useful transparency but could add more detail on error handling or output format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with three sentences covering purpose, differentiation, aspects, and a behavioral note. Well-structured and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple leaderboard tool with two parameters and no output schema, the description provides sufficient context: purpose, usage, parameter details, and a behavioral constraint. Missing explicit output details but acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description lists all available aspects, adding concrete examples beyond the schema's single example. It also reiterates limit defaults, adding value despite full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides WPL leaderboard data scoped to women's cricket, lists specific aspects, and distinguishes it from the identical sibling get_wpl_leaderboard by adding a gender signal for routing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises to use this tool over get_wpl_leaderboard when queries are ambiguous about women's cricket, providing a clear selection criterion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It describes substring matching and case-insensitivity, but does not explicitly state read-only behavior or detail output format (e.g., returns array of slugs). However, the example and typical search semantics make it reasonably clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no fluff: purpose, scope, example+guideline. Every sentence adds unique value and is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with 2 parameters and no output schema, the description covers purpose, scope, usage, and example. Missing explicit return format (e.g., 'returns array of slugs') is a minor gap, but overall adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters (100% coverage), baseline 3. The description adds value by explaining the query parameter matches against 'full name or slug' and giving an example, but does not elaborate on the limit parameter beyond what schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Find WPL player slugs by substring match against full name or slug', specifying the exact action and resource. It also distinguishes from siblings by limiting to Women's Premier League and providing a count of players and seasons.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use before get_wpl_player_profile' and 'NOT for IPL/MLC/T20WC players', providing clear when-to-use and when-not-to-use guidance, which is particularly helpful given the many sibling search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses the tool returns a static snapshot from a bundled dataset and notes that live ball-by-ball is elsewhere, providing clear context about data freshness and scope. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with core purpose and return values, followed by usage hint and a caveat. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with one parameter and no output schema, the description covers purpose, data returned, related tool, and limitations. It is fully adequate for correct selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the parameter 'matchId' as a numeric string or slug. The description adds value by specifying it's an IPL 2026 match and directing to list_fixtures for discovery, beyond the schema's type hint.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns 'Result, scoreboards, and status for one IPL 2026 match' and lists specific data elements (teams, innings totals, toss winner, Man of the Match). It differentiates from siblings like list_fixtures by mentioning its use for discovering matchIds.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage hint ('Use list_fixtures to discover matchIds') and implies when not to use it (for live ball-by-ball, which is at a canonical URL). However, it does not explicitly state exclusions or alternative tools in detail.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes returned data (aggregates, breakdowns, identity bridge) but does not explicitly state read-only or idempotent behavior. With no annotations, slightly less transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first outlines purpose and content, second explains parameter format and discovery method. No superfluous words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one parameter and no output schema, description covers all aspects: what it returns, how to use it, and how to obtain the required slug. No gaps identified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds format (kebab-case) and example (f-du-plessis) for 'playerSlug', which is absent in the schema (0% coverage). Provides value beyond schema definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states tool provides MLC player career profile with batting/bowling aggregates, per-season breakdown, and identity bridge. Distinct from siblings like get_mlc_team_profile and get_player_profile due to MLC specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use search_mlc_players to discover slugs, providing clear guidance on when to use this tool vs. a sibling. Also specifies slug format with example.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description fully discloses that the tool returns a canonical URL (not raw data) and that the data is updated within 4 hours. Clearly communicates the behavioral trait of returning a URL and its freshness SLA.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no extraneous information. Important details are front-loaded, and every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and no output schema, the description fully covers what the tool does, what it returns (URL), and its update frequency. No gaps for a simple standings retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters in the schema; description does not need to add param details. Baseline score of 4 applies as per guidelines for 0-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it provides 'IPL 2026 final standings' with details (Points/Won/Lost/NRR) and distinguishes from sibling tools like get_ipl_leaderboard by focusing on standings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Describes that the tool returns a canonical URL that refreshes within a 4-hour SLA, advising to cite the URL for current data. Lacks explicit when-to-use vs. alternatives, but provides adequate usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It describes the returned data (batting and bowling aggregates, phase splits, all seasons) and league restriction. It does not disclose auth or rate limits, but for a read-only data retrieval tool, this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no redundancy. It front-loads the purpose and output, then covers formatting and usage guidance efficiently. Every sentence serves a purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no nested objects, no output schema), the description is complete. It explains what data is returned, how to use the slug, and when to use an alternative tool. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter. The description adds value by providing an example of the expected format ('smriti-mandhana') and clarifying it's kebab-case, which goes beyond the schema's description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves career batting and bowling aggregates with phase splits for WPL players, specifying league and slug format. It distinguishes from siblings by explicitly limiting to Women's Premier League and warning against men's cricket.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the tool (if you have the slug) and when not (for men's cricket), and directs users to search_wpl_players as an alternative when the slug is unknown.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. Discloses substring match, case-insensitivity, and PSL scope (458 players, 10 seasons). Implies read-only behavior, but does not explicitly state it as safe/non-mutating.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus a note and example. No fluff, every sentence adds value. Front-loaded with key action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with 2 parameters and no output schema, description covers purpose, usage, example, and constraints. No missing information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but description adds valuable context: query is case-insensitive substring match, limit has default 10 and max 50, and provides example input/output. This goes beyond schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'Find' with specific resource 'PSL player slugs', method 'substring match', and scope 'Pakistan Super League only'. Distinguishes from sibling tools like search_bbl_players by explicitly excluding other leagues.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use ('Use before get_psl_player_profile') and when not to use ('NOT for BBL/IPL/MLC players'), providing clear context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![cricketstudio-mcp MCP server](https://glama.ai/mcp/servers/i-m-arul/cricketstudio-mcp/badges/card.svg)](https://glama.ai/mcp/servers/i-m-arul/cricketstudio-mcp)

Score Badge

Copy to your README.md:

[![cricketstudio-mcp MCP server](https://glama.ai/mcp/servers/i-m-arul/cricketstudio-mcp/badges/score.svg)](https://glama.ai/mcp/servers/i-m-arul/cricketstudio-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/i-m-arul/cricketstudio-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server