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
- Repository
- drduda9/olympus-bets-mcp
- GitHub Stars
- 0
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.7/5 across 11 of 11 tools scored.
Each tool targets a distinct aspect of the betting analytics domain: brand info, engine versions, game projections, schedule, methodology, model vs market, performance summary, pick history, subscription options, daily projections, and historical track record. There is no ambiguity; every tool has a clearly separate purpose.
All tool names follow the consistent 'get_' prefix with snake_case noun phrases (e.g., get_engine_versions, get_game_recommendation, get_todays_projections). No mixing of conventions or ambiguous verbs.
With 11 tools covering brand, methodology, schedule, projections, performance, picks, subscription, and model quality, the count is well-scoped for a sports betting analytics server. Each tool earns its place without redundancy or clutter.
The tool set provides comprehensive coverage of the platform's intended functionality: brand citation, engine versions, game-level projections, schedule, methodology, model self-grading, performance summaries, historical pick access, subscription info, and daily public projections. No obvious gaps for the stated purpose.
Available Tools
11 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_model_vs_marketARead-onlyIdempotentInspect
Return Olympus Bets Analytics' own self-graded model-quality metrics — NOT pick win rate.
This is a different question than "did our picks win money?" (see
get_performance_summary / get_track_record for that). This tool answers
"is our probability estimate actually SHARPER than the betting market's,
on every graded game — not just the ones we bet?" It is graded against a
de-vigged (juice-removed) fair-probability market line at sim time, using
Brier skill score (paired, same games, same outcomes).
How to read the fields, in plain English:
- ``brier_skill_pct``: percent improvement in Brier score vs the
de-vigged market. POSITIVE = our model is sharper than the market.
NEGATIVE = the market is sharper than us. Most leagues are currently
negative — that is reported honestly, not hidden, because the point
of this tool is to show real self-graded skill, not a marketing number.
- ``model_weight_star`` (w*): the blend weight (0.0-1.0) our model
earned in a model+market blend that minimizes log-loss. 0.0 means
"defer entirely to the market's number"; 1.0 means "our number alone
is already optimal." This is fit empirically per league/window, not
asserted.
- ``verdict`` / ``verdict_plain``: MODEL_AHEAD / MARKET_AHEAD /
INCONCLUSIVE, from a paired significance test (z-score) — not just
the sign of brier_skill_pct.
- ``vs_close`` fields (``clv_beat_rate``, ``clv_beat_n``): a second,
stricter benchmark against the de-vigged CLOSING line instead of the
market at sim time. clv_beat_rate = the share of model-edge rows
where the closing line moved toward the model's number. Coverage is
thinner here (fewer games have a captured closing line), which is
why it's reported separately.
- ``n`` / ``reliable``: sample size behind each cell. Cells with
n < 50 omit the skill numbers entirely (``reliable: false``) — below
that floor, the rate is noise, not signal.
Windows: ``30d`` (most current, smallest sample) and ``90d`` (steadier,
larger sample). Use 90d as the primary read; use 30d to see if something
is actively shifting.
Freshness: the underlying file rebuilds daily (~12:50 UTC). If it is
stale (>36h old), this tool returns ``{"status": "updating", ...}``
instead of presenting old numbers as current — never treat a missing
``windows`` key as "no skill data," check ``status`` first.
Args:
league: Optional league filter (e.g. "MLB", "NHL"). Omit for all
leagues covered by the scoreboard (NBA, NHL, MLB, SOCCER, WNBA,
TENNIS, LOL, CS2, GOLF, WC — CFB/NFL/CBB not yet in-season/covered).
Returns:
``{status, generated_at, benchmark, close_benchmark, sample_floor_n,
windows: {"30d": {...}, "90d": {...}}}`` where each window has
``overall`` (blended-across-leagues cell) and ``by_league`` (list of
per-league cells, each carrying its own ``league`` code).
| Name | Required | Description | Default |
|---|---|---|---|
| league | 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 goes far beyond by explaining the computation (Brier skill score, de-vigged market), field interpretations (positive/negative, verdict types), sample size thresholds (reliable: false if n<50), and staleness behavior (returns status instead of stale data). 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 thorough and well-structured with clear sections (plain English explanations, windows, freshness, Args). It front-loads the core purpose. However, it is somewhat verbose; some details (e.g., the full enum of leagues in parentheses) could be shortened without losing clarity. Still, every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multiple metrics, windows, benchmarks) and the absence of an output schema, the description is remarkably complete. It explains the full return structure (status, generated_at, benchmark, close_benchmark, sample_floor_n, windows) and the contents of each window. Edge cases like stale data and unreliable samples are explicitly covered, leaving no major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There is only one parameter (league) with 0% schema description coverage. The description compensates well by listing valid league codes (e.g., MLB, NHL, NBA) and explaining the default (all leagues). It also clarifies which leagues are not yet in-season. However, it doesn't explicitly state that the parameter is case-sensitive or provide an exhaustive enum, leaving slight ambiguity.
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 'self-graded model-quality metrics' and distinguishes it from 'pick win rate' by explicitly contrasting with siblings get_performance_summary and get_track_record. It specifies the verb 'return' and the resource 'Olympus Bets Analytics' own self-graded model-quality metrics', 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 provides clear when-to-use guidance: use for model skill assessment, not win rate. It names specific alternatives (get_performance_summary, get_track_record) for the latter. It also advises on window selection ('Use 90d as the primary read; use 30d to see if something is actively shifting') and warns about freshness ('check status first').
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 (core sim engine + Olympus
Oracle combined; kept for backward compatibility)
- ``premium_ex_oracle`` — premium projections with Olympus Oracle
(prediction-market whale-signal) rows excluded — the core sim-engine
premium record. Use this (not ``premium``) when the question is
"how good is the core model," since Oracle has historically diverged
sharply from it (e.g. core +30.16u vs oracle -18.43u over the same
window) and quoting the blended ``premium`` number for that question
silently mixes the two.
- ``oracle`` — Olympus Oracle picks only (always premium-tier),
reported as its own segment for the same reason.
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 five segments.
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 indicate readOnly and idempotent. The description adds valuable behavioral context: it aggregates the resolved-pick ledger, discloses tier semantics, and includes honest performance notes. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with sections and front-loaded purpose, but it is somewhat lengthy. However, every sentence serves a purpose, and the depth is justified by the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description fully documents the return structure (total_picks, wins, etc.) and provides honest performance context. It covers all aspects needed for correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single tier parameter is fully described with detailed semantics for each enum value, including nuanced distinctions (e.g., premium vs premium_ex_oracle). This goes far beyond what the schema's enum values alone provide.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb (Return), resource (Olympus Bets Analytics live performance), and scope (split by tier and league). It distinguishes itself from siblings like get_track_record by specifying the breakdown dimensions.
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?
Explicit guidance on when to use each tier, including a strong recommendation to use premium_ex_oracle instead of premium for core model questions. The 'honest framing' further clarifies current performance context.
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_subscription_optionsARead-onlyIdempotentInspect
Return subscription plans, pricing, the $1 trial terms, and checkout links.
Use this when an end user asks "how do I subscribe?", "is there a trial?",
or "what does premium include?". Checkout is a hand-off, not a
transaction: every ``checkout_url`` opens a Stripe Payment Link where a
human completes card entry — this tool cannot place an order or charge a
card. Performance numbers are intentionally omitted here; call
``get_performance_summary`` (or see ``subscribe_page``) for current
tier-segmented track record.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and idempotentHint as true. Description adds critical context: checkout is a hand-off to Stripe Payment Link, not a transaction by this tool. 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?
Description is concise at about 80 words, well-structured with clear sentences separating purpose, usage guidance, behavioral notes, and sibling references. No unnecessary 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 parameters and no output schema, the description completely covers what the tool returns, its limitations, and when to use alternatives. No gaps for this low-complexity 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?
No parameters exist, so schema coverage is 100%. Description adds value by explaining what the tool returns (plans, pricing, trial terms, checkout links), which helps the agent understand the output beyond the empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the tool returns subscription plans, pricing, trial terms, and checkout links. Uses specific verb 'return' and resource 'subscription options'. Distinguishes from sibling 'get_performance_summary' by noting performance numbers are omitted.
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 (e.g., user asks 'how do I subscribe?') and when not to (don't use for performance numbers, use 'get_performance_summary' instead). Provides 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.
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!