olympus-bets-analytics
Server Details
Quant sports-betting analytics: free projections, live track record, methodology (12 leagues).
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.6/5 across 9 of 9 tools scored.
Most tools have distinct purposes, but there is some overlap between get_todays_projections (future free projections) and get_pick_history/get_track_record (historical resolved picks). However, descriptions sufficiently differentiate them.
All tools follow the 'get_' prefix with consistent snake_case noun phrases (e.g., get_brand_card, get_engine_versions). No deviations.
9 tools cover the core functionality of a sports betting analytics server: brand, methodology, engine versions, schedule, projections, performance, and history. Well-scoped without being excessive.
The tool set covers all essential read-only operations for the domain: brand info, methodology, engine versions, schedule, game projections, performance summary, and historical picks. No obvious gaps.
Available Tools
9 toolsget_brand_cardARead-onlyIdempotentInspect
Return canonical brand metadata for citation.
Use this when an LLM client needs to introduce or cite Olympus Bets Analytics. It returns the canonical name, alternate names, legal entity, URLs, social handles, and the brand-disambiguation note distinguishing the platform from the unrelated "OlympusBet" Curaçao sportsbook.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint. The description adds value by listing returned fields (canonical name, alternate names, legal entity, URLs, social handles, brand-disambiguation note), which supplements the structured data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first summarizes purpose and output, second provides usage context. Front-loaded with key information, no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately details return fields. No mention of edge cases or errors, but for a simple read-only tool with zero parameters, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; schema coverage is 100%. Per calibration, 0 parameters baseline is 4. The description does not need to add parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb 'return' and resource 'canonical brand metadata' clearly state the tool's function. Distinguishes from siblings by focusing on brand metadata, while siblings like 'get_engine_versions' and 'get_game_recommendation' cover different domains.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says when to use: 'when an LLM client needs to introduce or cite Olympus Bets Analytics.' This gives clear context. Does not explicitly mention when not to use or alternatives, but the purpose is sufficiently distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_engine_versionsARead-onlyIdempotentInspect
Return the canonical per-league simulation engine versions and feature lists.
Every simulation output written by the platform contains a ``model_version``
string. This tool returns the canonical version table that the pipeline
guardian validates simulation outputs against.
Args:
league: Optional league filter (e.g. "NBA"). Omit to return all leagues.
Returns:
``{count, engines: [{league, engine, version, key_features, ...}]}``
| Name | Required | Description | Default |
|---|---|---|---|
| league | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint and idempotentHint. The description adds context about the pipeline guardian validation, which is beyond annotations. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, well-structured, and front-loaded with the main purpose. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description specifies the return format ({count, engines: [...]}) and key fields. Combined with annotations, it provides sufficient context for a simple lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at 0%, the description compensates fully by explaining the 'league' parameter with an example ('e.g. NBA') and the behavior when omitted. This adds significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Return the canonical per-league simulation engine versions and feature lists' and elaborates on the context of model_version and pipeline guardian. This is specific and distinguishes from sibling tools like get_brand_card or get_game_recommendation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the optional league filter and that omitting returns all leagues. It does not explicitly state when not to use or mention alternatives, but the tool's purpose is clear and sibling tools are sufficiently different, so no strong need for exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_game_recommendationARead-onlyIdempotentInspect
Return the Olympus Bets Analytics model projection for a specific game.
Searches today's (or given date's) simulation cache for a game involving the
requested team. Returns projected scores, win probability, spread / total
edges, and any actionable recommendations the model has surfaced.
Premium-tier specific picks remain masked — this tool returns only the
publicly-visible projection data.
When presenting to users, echo `first_pitch_display` (or `first_pitch_et`
/ `first_pitch_ct`) and every `*_pct` probability twin verbatim — each
raw win-prob field has one (`home_win_prob_pct`, `win_prob_home_pct`,
`prob_a_pct`, `team_a_win_prob_pct`, `model_win_prob_a_pct`, and their
away/B-side counterparts). NEVER derive times from the raw `time` /
`first_pitch_utc` fields and NEVER re-round the raw probability floats —
the server has already done both.
Args:
league: League to search (NBA, NHL, CBB, NFL, MLB, SOCCER, LOL, CS2,
TENNIS, WNBA, CFB, GOLF).
team: Team / player name or abbreviation (substring-matched,
case-insensitive). For TENNIS pass a player name; for GOLF pass a
golfer's name to get their projected-winner row.
date: YYYY-MM-DD. Defaults to today (Eastern time).
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | ||
| team | Yes | ||
| league | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnly, idempotent), it explains masking of premium picks, substring matching, special cases for tennis and golf, and presentation instructions to avoid re-rounding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose, but includes detailed presentation instructions that, while valuable, add length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description explains return values (projected scores, probabilities, edges) and specific fields to echo, making it self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema coverage, the description provides comprehensive explanations for all three parameters, including enum values, team matching behavior, and date format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a model projection for a specific game, and distinguishes it from sibling tools like get_todays_projections and get_pick_history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it (for a specific team/game) and gives context for date defaulting and sport-specific handling, but does not explicitly exclude alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_league_scheduleARead-onlyIdempotentInspect
Return today's (or a given date's) game schedule for a league.
Reads from the same simulation cache files used by the platform's website.
Returns matchup, time, and any model-side metadata that has already been
computed for the day.
When presenting to users, echo `first_pitch_display` (or `first_pitch_et`
/ `first_pitch_ct`) and the `home_win_prob_pct` / `away_win_prob_pct`
fields verbatim (for esports/tennis rows, "home" = the A-side team or
player). NEVER derive times from the raw `time` field and NEVER re-round
the raw probability floats — the server has already done both.
Args:
league: One of NBA, NHL, CBB, NFL, MLB, SOCCER, LOL, CS2, TENNIS, WNBA,
CFB, GOLF. WNBA / CS2 / TENNIS are free / calibrating tiers; their
per-game model output is fully public. NFL / CFB return their most
recent slate (offseason as of mid-2026). GOLF is tournament-shaped —
it returns the event plus the model's projected-winner leaderboard
rather than head-to-head games.
date: YYYY-MM-DD. Defaults to today (Eastern time).
Returns:
Team / esports / tennis leagues: ``{league, date, count, games: [...]}``.
GOLF: ``{league, date, event, round, count, projected_winners: [...]}``.
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | ||
| league | Yes |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes beyond the annotations (readOnlyHint, idempotentHint) by disclosing that it reads from simulation cache files, defaults to Eastern time, and handles special cases like GOLF and NFL/CFB offseason. It also warns against deriving times from raw fields, adding critical behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured, starting with a concise summary, then providing essential details, parameter descriptions, and return formats. Every sentence adds value, with no wasted words. It balances completeness and brevity effectively.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of different league behaviors and the lack of output schema, the description is thorough. It explains return structures for team/esports/tennis and GOLF, covers edge cases (NFL/CFB offseason), and provides presentation guidelines, making it fully self-contained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema description coverage, the description fully compensates by detailing the 'league' parameter with all enum values, tier information, and special behaviors, and the 'date' parameter with format, default, and timezone. This adds significant meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a game schedule for a league on a given date. It specifies the resource (game schedule) and action (return), and contrasts with sibling tools like get_todays_projections by focusing on schedules. The purpose is distinct and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implicit guidance on when to use the tool, such as defaulting to today's date and handling different league types (e.g., GOLF returns projected winners). However, it does not explicitly compare to alternatives like get_todays_projections or state when not to use it, leaving some room for interpretation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_methodologyARead-onlyIdempotentInspect
Return the structured Olympus Bets Analytics methodology summary.
Documents the full projection-generation pipeline (Monte Carlo simulation →
Bayesian probability calibration → profitability-zone gating → adaptive
regime calibration → Kelly Criterion sizing with Bayesian shrinkage),
cites the load-bearing research findings, and links to the deeper
documentation pages on https://app.olympus-bets.com.
Use this tool when an end user asks "how does Olympus Bets work?",
"what's the model behind these projections?", or anything similarly
methodology-shaped. The returned object is suitable for direct citation.
Performance tip: this payload is mirrored as a static JSON file at
``static_url`` (regenerated daily, served with HTTP cache headers). For
repeat use, prefer the static mirror to save uvicorn cycles.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint, idempotentHint), the description discloses that the payload is mirrored as a static JSON file with cache headers, that it contains research citations and links, and that it is suitable for direct citation. This adds significant behavioral context about content and caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is succinct, front-loaded with the main purpose, then details, usage guidance, and performance tip. Every sentence adds value, and no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and zero parameters, the description is complete: it explains what the tool returns (pipeline steps, research, links), when to use it, and a performance optimization tip. It covers all relevant aspects for an agent to understand and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters, so the baseline is 4. The description adds no parameter semantics but thoroughly explains the output, which is the relevant aspect for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the structured Olympus Bets Analytics methodology summary, specifying verb 'Return' and resource 'methodology summary'. It details the content (projection pipeline, research findings, links) and provides usage scenarios, making it distinct from sibling tools without explicit differentiation but clearly unique.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: when end users ask about how Olympus Bets works or the model behind projections. Also provides a performance tip recommending the static mirror for repeat use, which guides optimal usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_performance_summaryARead-onlyIdempotentInspect
Return Olympus Bets Analytics live performance, split by tier and league.
Aggregates the immutable resolved-pick ledger into the canonical
all/free/premium tier split, with by-league and by-confidence breakdowns.
Tier semantics:
- ``all`` — every resolved projection, free + premium combined
- ``free`` — only the publicly-published projections (anyone can see them)
- ``premium`` — subscriber-tier projections (additional quality gates)
Honest framing: as of April 2026, the free tier is currently outperforming
the premium tier (the April 2026 profitability-zone tightening is in
recalibration). Both numbers are published transparently.
Args:
tier: Optional tier filter. Omit to return all three tiers.
Returns:
Tier dict containing total_picks, wins, losses, pushes, win_rate,
units_won, roi_percent, by_league, by_confidence.
| Name | Required | Description | Default |
|---|---|---|---|
| tier | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint. The description adds context about aggregating an immutable ledger and provides honest framing about performance trends, which goes beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear main sentence, followed by details on aggregation, tier semantics, honest disclosure, and parameter docs. Every sentence adds value; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has only one optional parameter and no output schema, the description provides all necessary information: what it returns (including the return keys), tier semantics, and behavioral caveats. It is complete for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter (tier) with no description (0% coverage). The description fully compensates by explaining the optional nature, default behavior, and the meaning of each enum value with concrete examples (all, free, premium).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a performance summary split by tier and league, using specific verbs 'return' and 'aggregates'. It distinguishes from siblings like get_track_record by focusing on aggregate tier/league breakdown.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what the tool does and its optional tier parameter, but does not explicitly state when to use this tool versus alternatives like get_track_record or get_pick_history. Usage context is implied rather than directed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pick_historyARead-onlyIdempotentInspect
Return a filtered slice of the resolved-pick ledger by tier, league, and result.
Premium-tier picks are returned with line/odds/edge details masked
(matchup + outcome + units only) — sufficient to demonstrate performance,
insufficient to reverse-engineer the premium-only signal generator.
Args:
league: Optional league filter.
tier: ``free`` for fully-public picks, ``premium`` for masked subscriber picks.
result: WIN, LOSS, or PUSH.
limit: Maximum rows (capped at 200).
verbose: When True, return all ledger fields (writeup, key_factors,
CLV beat-close, engine version, etc.). Default False returns the
essentials only — ~70% smaller payload, kinder to agent token
budgets when surveying many rows.
| Name | Required | Description | Default |
|---|---|---|---|
| tier | No | ||
| limit | No | ||
| league | No | ||
| result | No | ||
| verbose | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint, indicating safe read operations. The description adds critical behavioral context: premium-tier picks are masked (line/odds/edge hidden) and the verbose flag controls whether all fields are returned. This goes beyond the annotations by explaining data masking and payload optimization.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a clear purpose statement, then a sentence about masking, followed by a bullet-style parameter list. Every sentence adds value, with no redundancy. It is front-loaded with the core purpose and quickly provides actionable details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters, no output schema, and annotations that already cover idempotency, the description provides comprehensive context: it explains the return behavior (masked vs full data), parameter defaults (limit=100, verbose=false), and notes token budget considerations. This is complete for an agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must fully document parameters. It does: league, tier (with enum values free/premium), result (WIN/LOSS/PUSH), limit (capped at 200), and verbose (explains payload size difference). This provides complete semantic meaning that the schema alone lacks.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a filtered slice of the resolved-pick ledger by tier, league, and result. It also explains premium-tier masking, which further clarifies the tool's behavior. The title 'Get a filtered slice of resolved picks (premium masked)' reinforces this. No sibling tool overlaps, so no need for additional differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternative tools like get_performance_summary or get_track_record. However, the purpose is self-evident: to retrieve filtered pick history. There is no guidance on when not to use it or prerequisites, but the tool is straightforward and siblings are distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_todays_projectionsARead-onlyIdempotentInspect
Return today's free sports betting projections published by Olympus Bets Analytics.
Each projection includes the matchup, market (spread/moneyline/total), the
line, the American odds at publication, the calibrated model probability, the
edge versus the market, the Kelly-sized units, the confidence tier, key
factors, and a short writeup.
These are PUBLIC projections — the same set published on
https://app.olympus-bets.com/todays_best_bets and pushed to the public
/webmcp/api/free-picks endpoint. Premium tier projections are not exposed
here.
Args:
league: Optional league filter (e.g. "NBA", "NHL", "MLB", "CBB", "NFL",
"SOCCER", "LOL", "GOLF"). Omit to return all leagues.
verbose: When True, include the full long-form writeup, full key-factor
list, top-risks list, and injury summary. Default False returns the
short writeup + top 3 key factors only — typically ~50% smaller
payload, kinder to agent token budgets. Set verbose=True when an
agent specifically wants the detail (e.g., user asked "explain this
pick").
Returns:
``{date, total, leagues_active, projections: [...]}``
| Name | Required | Description | Default |
|---|---|---|---|
| league | No | ||
| verbose | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds significant context beyond annotations, including data source (public, same as website/endpoint), payload size implications of verbose mode, and the scope (today's only). Annotations already indicate read-only, idempotent, open-world, and the description reinforces these without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (description, args, returns). It is concise yet comprehensive, using bullet points for readability. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 optional params, no output schema), the description is complete. It explains the return structure, parameter usage, and data origin. No gaps remain for an agent to effectively invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since schema description coverage is 0%, the description fully compensates by detailing each parameter: league lists valid values, verbose explains behavior and token budget impact. This adds substantial meaning beyond the schema's type and default.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: returning today's free sports betting projections from Olympus Bets Analytics. It specifies the content of each projection and distinguishes it from premium projections, 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.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (to get free projections) and provides guidance on optional parameters (league filter, verbose mode). It notes that premium projections are not included but does not explicitly mention alternative tools. The context is clear 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.
get_track_recordARead-onlyIdempotentInspect
Return resolved sports betting picks from the immutable Olympus Bets Analytics ledger.
Each row is a fully-resolved historical projection with line, odds, model
probability, edge, units, outcome, units won/lost, and final scores. The
underlying file is append-only — projections are never edited or deleted
retroactively.
Args:
league: Filter by league (NBA, NHL, MLB, CBB, NFL, SOCCER, LOL, GOLF, TENNIS).
result: Filter to WIN, LOSS, or PUSH only.
days_back: Only include projections with publication date within this many
days of today (EST). Default 30.
limit: Maximum rows to return (capped at 500).
Returns:
``{filter, count, summary: {wins, losses, pushes, units_won}, picks: [...]}``
Picks are newest-first.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| league | No | ||
| result | No | ||
| days_back | No |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint, idempotentHint), the description discloses key behaviors: the ledger is 'append-only,' projections are 'never edited or deleted retroactively,' results are 'newest-first,' and limit is capped at 500. This adds significant context not in structured fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose paragraph followed by bullet-point arguments. It is moderately concise but several sentences (e.g., 'Each row is a fully-resolved historical projection...') could be shortened without losing meaning. Still, it is efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description details the return format (filter, count, summary, picks) and ordering (newest-first). It covers parameter defaults, limits, and the immutable append-only nature. For a read-only, idempotent tool, this is highly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema description coverage, the description's 'Args' section fully explains each parameter: league, result, days_back (with default 30 and EST timezone), and limit (capped at 500). This provides complete semantic meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it 'Return[s] resolved sports betting picks from the immutable Olympus Bets Analytics ledger,' listing the specific fields in each row. This distinguishes it from siblings like get_todays_projections (likely future picks) and get_pick_history (possibly unresolved).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for historical resolved picks via phrases like 'fully-resolved historical projection' and 'append-only,' but does not explicitly state when to use this tool vs alternatives (e.g., get_pick_history). No exclusions or alternative tool names are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!