Gamechalk Score Keeper
Server Details
Scoreboard & game scores
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 3 tools
Each tool targets a distinct game domain (darts, dice sheet, generic scoreboard) and descriptions explicitly cross-reference each other with 'do not use for X' guidance. Minor residual risk: an agent might use show_scoreboard for dice or darts before reading the disclaimers, but naming and descriptions make the boundaries clear.
Names mix a verb_theme_noun pattern: score_darts_leg and score_dice_sheet share a prefix, but show_scoreboard switches to a different verb (show) and drops the domain qualifier. Still readable and internally meaningful, just not a single predictable convention.
Three tools for three distinct game types is lean but each earns its place; nothing is redundant. It sits at the low end where a fourth variant (cricket, full matches) would be a natural addition, but scope is coherent.
Covers the stated scoring needs: darts legs with bust/checkout logic, dice sheet categories and bonuses, and a generic live scoreboard. Known stated exclusions (cricket, multi-leg matches) are deliberate scope limits rather than accidental gaps, though cricket omission is a notable darts gap.
Available Tools
3 toolsscore_darts_legScore darts legARead-onlyIdempotentInspect
Use this when the user wants a 501 or 301 darts leg scored: "score my 501 leg", "I threw T20 T20 T20, then S20, then out on D10", "darts scorer, double out". Send each visit to the oche as a turn of up to 3 darts (formats: S20, D16, T19, SB, DB, or 0). Applies standard bust rules (a bust scores nothing and the turn ends; darts after a finish are ignored; double-out requires a double or inner bull to finish unless double_out is false). Returns remaining, per-turn detail, busts, darts thrown, the three-dart average, a checkout suggestion when one exists, and a CSV of the leg. It is not for cricket or around-the-clock variants, and it does not track multi-leg matches — one leg per call.
| Name | Required | Description | Default |
|---|---|---|---|
| start | Yes | Leg starting score: 501 (standard) or 301. | |
| turns | Yes | Turns in order; each turn has up to 3 darts. A new entry per visit, e.g. one turn containing T20 and D20. | |
| double_out | No | Require a double (or inner bull) to finish, e.g. true for a double-out leg. Default true. |
Output Schema
| Name | Required | Description |
|---|---|---|
| busts | Yes | |
| start | Yes | |
| turns | Yes | |
| scored | Yes | |
| csv_url | Yes | |
| checkout | Yes | |
| finished | Yes | |
| downloads | Yes | |
| remaining | Yes | |
| double_out | Yes | |
| darts_thrown | Yes | |
| three_dart_average | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds substantive domain behavior beyond that: bust rules, ignored darts after a finish, double-out requirements, and what the response includes (remaining, per-turn detail, busts, average, checkout suggestion, CSV). This is unusually complete behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with intent examples, then rules, then exclusions. Despite covering several important constraints, every sentence contributes directly to correct invocation or scoping.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description need not explain return shape in detail, but it still summarizes important outputs. Combined with 100% schema coverage and clear annotations, an agent has everything needed to call the tool correctly and understand its behavioral limits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so start, turns, darts, and double_out are already documented in the schema. The description reinforces the turn grouping and dart formats, but mostly restates schema-level details rather than adding new parameter semantics, making the baseline 3 appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('score a 501 or 301 darts leg') and immediately distinguishes the scope with concrete user phrasings. It also explicitly rules out cricket and around-the-clock variants, so the agent can separate this from unrelated siblings like score_dice_sheet and show_scoreboard.
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 explicit when-to-use examples and clear exclusions: not for cricket or around-the-clock, and not for multi-leg matches. It also states the one-leg-per-call constraint, leaving little ambiguity about when to invoke it versus not.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
score_dice_sheetScore dice sheetARead-onlyIdempotentInspect
Use this when the user wants a five-dice score sheet scored: "score my sheet, full house [5,5,5,2,2]", "what did I score for chance [3,4,4,5,6]", "tally my dice game". Pass each played category with its 5 dice, and null (or omit) for skipped categories. Returns the category scores, the upper-section total, the 35-point upper bonus when the upper total reaches 63, five-of-a-kind bonuses (100 per repeat after the first 50; provide play_order for chronology, otherwise listed category order is assumed), the grand total, and a CSV of the sheet. It does not choose categories for you and is not for board games — use show_scoreboard for plain point totals.
| Name | Required | Description | Default |
|---|---|---|---|
| sheet | Yes | Score sheet state: map each category name to the five dice rolled (e.g. [5,5,5,2,2]) if you played that category, or null if you skipped it. Category keys: ones, twos, threes, fours, fives, sixes, three_of_a_kind, four_of_a_kind, full_house, small_straight, large_straight, five_of_a_kind, chance. | |
| play_order | No | Played categories in chronological order, e.g. [five_of_a_kind, chance]. Include each played category once. If omitted, assumes the listed category order (ones through chance) for repeat bonuses. |
Output Schema
| Name | Required | Description |
|---|---|---|
| total | Yes | |
| csv_url | Yes | |
| downloads | Yes | |
| categories | Yes | |
| upper_bonus | Yes | |
| upper_total | Yes | |
| five_of_a_kind_bonus | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond the readOnly/idempotent annotations by disclosing the actual scoring rules that affect the result: the 63-point threshold for the 35-point upper bonus, 100-per-repeat five-of-a-kind bonuses, and that repeat bonuses depend on play_order chronology with a documented fallback ordering. It also states the response payload, including a CSV of the sheet.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the trigger and examples before the mechanics and exclusions, and every sentence carries information. The three quoted utterances are slightly repetitive but serve as disambiguation evidence, so the cost is small.
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?
For a tool with a nested object parameter and an output schema, this covers everything an agent needs: trigger phrasing, input shape for played vs. skipped categories, the ordering rule that changes bonus output, and a clear boundary against the sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the description only needs to add nuance. It does supply one thing the schema leaves implicit — that skipped categories may be null OR omitted — and ties play_order to the repeat-bonus computation rather than restating it as a list of names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (score) and resource (five-dice score sheet) and grounds it in three concrete user utterances ("score my sheet, full house [5,5,5,2,2]"). It explicitly separates itself from the sibling show_scoreboard, so an agent can route between them without inspecting schemas.
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?
Opens with an explicit trigger condition ("Use this when the user wants..."), gives worked request examples, and states exclusions: it does not pick categories for the user and is not for board games — use show_scoreboard instead. Both the when and the when-not are present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
show_scoreboardShow scoreboardARead-onlyInspect
Use this when the user wants a live scoreboard: "keep score for me and Anna", "scoreboard for game night with 4 players", "add 12 points to Anna". Pass mode highest (default), lowest, or target with a positive target score. Scores stay in the open widget only; no online multiplayer. Shows a widget with one row per player, +N/-N buttons (use Smaller step and Bigger step to change the step), undo and history for the last 20 score changes with round numbers, and running totals. Pass the initial player names (2-12); totals start at 0 unless you pass initial scores. Do not use it to score dice sheets or darts legs — use score_dice_sheet or score_darts_leg for those.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | Win mode, e.g. lowest for a penalty game, highest (default), or target for first to a target score. | |
| scores | No | Optional starting totals, same order and length as players. Default 0, e.g. [25,0]. | |
| target | No | Required target for target mode, e.g. 100. Ignored for highest/lowest modes. | |
| players | Yes | Player names in seating order, e.g. ["Anna", "Ben"]. 2-12 players. |
Output Schema
| Name | Required | Description |
|---|---|---|
| mode | Yes | |
| note | No | |
| target | No | |
| players | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, it discloses the widget's actual behavior: one row per player, +N/-N buttons with adjustable step, undo and 20-entry history with round numbers, running totals. It also scopes the tool ("scores stay in the open widget only; no online multiplayer"), which is a genuine persistence/scope constraint the annotations do not express. No conflict with readOnlyHint=true, since the description claims no persistent or external writes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads usage triggers, then behavior, then exclusions — a sensible order with no filler. It is a single dense paragraph and slightly long, but each sentence carries selection-relevant content rather than repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 parameters fully documented in schema, an output schema present, and annotations covering safety, the description fills the remaining gaps: widget contents, history depth, player-count bounds, and the sibling routing. An agent has everything needed to decide and call correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the description largely restates what the schema already documents: mode options and default, positive target for target mode, 2-12 players, and starting totals of 0. The sentence about initial player names and starting scores helps orient the agent but adds little beyond the structured fields, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource — a live scoreboard widget — and immediately differentiates it from both siblings (score_dice_sheet, score_darts_leg) by name. The opening trigger phrases make the resource concrete enough to match against a user request.
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?
Gives explicit positive triggers ("keep score for me and Anna", "scoreboard for game night with 4 players") and an explicit negative case with the two alternative tools to use instead. Nothing about when to select this tool is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
score_darts_leg - First observed
score_dice_sheet - First observed
show_scoreboard
Related MCP Connectors
Highlightly MCP — cheap multi-sport scores, video highlights, and match
Live scores, play-by-play, box scores, odds, injuries: NFL, NBA, NHL, MLB, NCAA, 23 soccer leagues
Live scores, fixtures, standings, team profiles and news for 2000+ football and basketball leagues.
Related MCP Servers
AlicenseAqualityBmaintenanceLive and prematch sports odds, scores, live statistics and match search from SportAPI (football, basketball, tennis, esports and more). Works with demo data without an API key.1134 PyPIMIT- AlicenseNot gradedqualityAmaintenanceGet live scores, schedules, standings, team and player data for NFL, NBA, MLB, NHL, soccer, and more via MCP.84 npm2Apache 2.0
- FlicenseNot gradedqualityBmaintenanceEnables live NFL and NBA scores, box scores, schedules, standings, player stats, team hubs, and news inside VoiceOS via native tappable notch cards, with keyless ESPN data and local MCP integration.-
- AlicenseNot gradedqualityBmaintenanceESPN MCP — keyless multi-sport live scores, teams, and news via ESPN's public site API.50 npmMIT
Glama MCP Gateway
Add one secure layer between your agents and this server.