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.
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?
Annotations already declare readOnlyHint and idempotentHint true. Description adds value by disclosing that premium picks are masked and only public data is returned, plus substring matching and date defaults. 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?
Well-structured with succinct first sentence stating purpose, followed by detailed behavior and args list. Every sentence contributes value. Front-loaded with key action.
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, description fully specifies return values (projected scores, win probability, edges, recommendations) and input behavior (cache search, masking). Complete for a 3-param tool with no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% description coverage, but the description's Args section thoroughly explains each parameter: league enum values, team as case-insensitive substring match, date format YYYY-MM-DD with default. This fully compensates for schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it returns model projections for a specific game. Specifies verb 'return', resource 'model projection', and scope. Differentiates from siblings by focusing on a single game with team/date.
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?
Provides clear context for when to use (searches simulation cache for a game with requested team/date) but does not explicitly mention alternatives or when not to use. The sibling list exists but is not referenced.
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.
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 complements annotations (readOnlyHint, idempotentHint) by detailing that it reads from simulation cache files, returns model-side metadata, and explains varying behavior per league (e.g., calibrating tiers, golf's tournament shape). 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 well-structured with clear sections (Args, Returns) and no superfluous information. Every sentence adds value, covering purpose, parameter details, and return shapes 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 complexity of the tool (multiple league types, different return structures, calendar behavior), the description is fully complete. It explains return formats for both standard and golf cases, and addresses offline seasons. No output schema exists, so the description adequately handles return values.
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 provides thorough parameter semantics: league values are explained with special notes on WNBA/CS2/TENNIS, NFL/CFB, and GOLF. The date parameter format and default are clearly specified. This adds significant value 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?
Description clearly states it returns the game schedule for a league on a specific date. The verb 'Return' and resource 'game schedule for a league' are explicit, and the tool is distinct from siblings like get_todays_projections 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 provides clear context for when to use the tool, including details about league-specific behaviors (e.g., NBA vs GOLF) and date handling. However, it does not explicitly mention when not to use it or suggest alternative tools, which would elevate the score.
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. The description adds important behavioral details: premium-tier picks have masked line/odds/edge, verbose mode increases payload by ~70%, and the limit is capped at 200. No contradictions 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 concise, with a clear opening sentence followed by bullet-pointed parameter explanations. Every sentence adds value: masking behavior, payload size trade-off, and limit cap. No extraneous content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description covers return behavior (masked vs full, verbose vs default), filtering parameters, and the concept of a ledger. For a retrieval tool with five optional parameters, this is comprehensive enough for an agent to understand what to expect.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters fully. It does so: league (optional filter), tier (free vs premium with masking implications), result (WIN/LOSS/PUSH), limit (max 200), verbose (false = essentials only, true = full fields). This compensates completely for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool's function: returning a filtered slice of the resolved-pick ledger by tier, league, and result. It also notes selective masking for premium tiers, distinguishing it from siblings like get_performance_summary or get_track_record. The verb 'Return' with specific filter dimensions provides clear purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use verbose mode (for full fields) versus default (for smaller payload), and mentions the limit cap at 200. It implies filtering context but does not explicitly state when to prefer this over sibling tools. However, the guidance is clear enough for most use cases.
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!