_ registry / mcp streamable-http · checked 7m ago

moddable-tools

https://tools.moddable.games

Registry code: ebdbbab6eb16c72b

api record

15 tools for chess variant analysis, hex map generation, and board game utilities

from a public catalogue that lists it, not from the operator

endpoint
https://tools.moddable.games/mcp
protocol
streamable-http ·2025-03-26
authentication
none observed
public key
none — nobody has proven they own this listing
karma
0 · newcomer
reachable
live
uptime
100%
latency
810ms

last good check

priced tools
0

of 89 tools

_ what it is for
topic
games & entertainment games
used for
  • get board layout details
  • get board gallery statistics
  • generate chess puzzle
  • list puzzle types
  • calculate dice probability
takes → gives
data → data
tools
36 reads4 changes data
_ used through this hub 30 days

The one measurement on this page that an operator cannot produce by editing a file on its own server: somebody else chose it, and paid to. Read the accounts before the calls — volume from one account is one relationship, and calling yourself is the cheap half. Both are what the ranking is built from, printed so the order can be checked rather than taken on trust.

accounts
0

distinct, expensive to fake

calls served
0

successful, last 30 days

_ what it can do 89 tools
3 open 86 never probed 3 of 89 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • board_gallery_search open 7m ago

    Search the board gallery (334 rendered board layouts across 33 game families)

    mcp-tool

    {
  "type": "object",
  "properties": {
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    },
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"8x8\", \"hex\", \"shogi\")"
    }
  }
}
    arguments 13 lines
  • board_gallery_stats reads open 7m ago

    Get statistics about the board gallery (total boards, families, topologies)

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • chess_get_status open 7m ago

    [DEPRECATED — use play_check_status] Get chess game status. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
    arguments 8 lines
  • ti4_draw_objectives reads unknown never probed

    Draw random public objectives for TI4

    mcp-tool

    {
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number to draw (default: 5)"
    },
    "stage": {
      "enum": [
        1,
        2
      ],
      "type": "number",
      "description": "Stage 1 or 2 (default: both)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}
    arguments 24 lines
  • ti4_draw_agendas unknown never probed

    Draw random agenda cards for TI4 political phase

    mcp-tool

    {
  "type": "object",
  "properties": {
    "type": {
      "enum": [
        "law",
        "directive"
      ],
      "type": "string",
      "description": "Filter by type"
    },
    "count": {
      "type": "number",
      "description": "Number to draw (default: 2)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}
    arguments 24 lines
  • nukes_setup_generator reads unknown never probed

    Generate random territory/resource setup for a Nukes game

    mcp-tool

    {
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (2-6, default: 2)"
    }
  }
}
    arguments 9 lines
  • game_nukes_combat reads unknown never probed

    Resolve a Nukes combat encounter between units

    mcp-tool

    {
  "type": "object",
  "required": [
    "attacker",
    "defender"
  ],
  "properties": {
    "terrain": {
      "type": "string",
      "description": "Terrain type (plains, forest, mountain, urban)"
    },
    "attacker": {
      "type": "string",
      "description": "Attacking unit type"
    },
    "defender": {
      "type": "string",
      "description": "Defending unit type"
    }
  }
}
    arguments 21 lines
  • colony_dice_odds reads unknown never probed

    Calculate settlement dice probability for Colony/Catan-style resource numbers

    mcp-tool

    {
  "type": "object",
  "required": [
    "numbers"
  ],
  "properties": {
    "numbers": {
      "type": "string",
      "description": "Settlement numbers, comma-separated (e.g. \"5,6,8,9\")"
    }
  }
}
    arguments 12 lines
  • rules_get_game_meta unknown never probed

    Get structured metadata for a game: players, duration, complexity, mechanics, how_to_play, variant list, page list, related games. Lightweight alternative to fetching the full rulebook.

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, cairn)"
    }
  }
}
    arguments 12 lines
  • rules_get_page reads unknown never probed

    Get a specific page/section from a game rulebook (e.g. character creation, combat rules, marketplace). Use rules_get_game_meta to see available pages.

    mcp-tool

    {
  "type": "object",
  "required": [
    "game",
    "page"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. cairn, dnd-5e)"
    },
    "page": {
      "type": "string",
      "description": "Page slug (e.g. character-creation, combat-and-difficulty)"
    },
    "section": {
      "type": "string",
      "description": "Section name (e.g. rules, classes, spells). Default: rules"
    }
  }
}
    arguments 21 lines
  • chess_render_svg unknown never probed

    [DEPRECATED — use play_render_board] Render a chess position as SVG. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "fen": {
      "type": "string",
      "description": "FEN position string"
    },
    "variant": {
      "type": "string"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Squares to highlight (e.g. [\"e2\",\"e4\"])"
    }
  }
}
    arguments 19 lines
  • rules_get_game unknown never probed

    Get full rulebook content for a specific game (markdown). For metadata only, use rules_get_game_meta instead.

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, dnd-5e, catan)"
    }
  }
}
    arguments 12 lines
  • rpg_random unknown never probed

    Get random entities from an RPG system for inspiration or encounter prep

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug"
    },
    "count": {
      "type": "number",
      "description": "Number of random picks 1-10 (default: 1)"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    },
    "category": {
      "type": "string",
      "description": "Category to draw from (omit for any)"
    }
  }
}
    arguments 24 lines
  • ti4_random_factions reads unknown never probed

    Generate random faction assignments for Twilight Imperium 4th Edition

    mcp-tool

    {
  "type": "object",
  "required": [
    "players"
  ],
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (3-8)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}
    arguments 19 lines
  • ti4_draft_factions reads unknown never probed

    Milty-style TI4 draft with pick pools per player

    mcp-tool

    {
  "type": "object",
  "properties": {
    "choices": {
      "type": "number",
      "description": "Factions per player to choose from (default: 3)"
    },
    "players": {
      "type": "number",
      "description": "Number of players (3-8, default: 6)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}
    arguments 20 lines
  • ti4_list_factions unknown never probed

    List all TI4 factions with colors, flags, and expansion info

    mcp-tool

    {
  "type": "object",
  "properties": {
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Filter by expansion (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}
    arguments 12 lines
  • jam_status unknown never probed

    Get the current Mod Jam status (active jam, deadline, submissions)

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • chess_generate_puzzle reads unknown never probed

    Get a random chess puzzle. Filter by variant or difficulty. Variant puzzles have no themes and max rating 1400 — theme and hard difficulty filters only apply to standard puzzles.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "theme": {
      "type": "string",
      "description": "Puzzle theme (fork, pin, skewer, mateIn2, etc). Only standard puzzles carry themes."
    },
    "variant": {
      "type": "string",
      "description": "Chess variant slug, camelCase or kebab-case (e.g. antichess, almost-chess, atomic, chess960, standard). Returns only puzzles for this variant."
    },
    "difficulty": {
      "enum": [
        "easy",
        "medium",
        "hard"
      ],
      "type": "string",
      "description": "Puzzle difficulty (variant puzzles max at 1400, so hard returns nothing for variants)"
    }
  }
}
    arguments 22 lines
  • chess_list_puzzle_types reads unknown never probed

    List available puzzle variants, themes, and per-variant counts from the puzzle pool

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • chess_list_variants unknown never probed

    [DEPRECATED — use play_list_variants] List chess variants. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "group": {
      "type": "string"
    }
  }
}
    arguments 8 lines
  • chess_get_legal_moves unknown never probed

    [DEPRECATED — use play_create_game + play_get_moves] Get legal moves for a chess position. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
    arguments 8 lines
  • chess_analyze_position unknown never probed

    [DEPRECATED — use play_suggest_move] Analyse a chess position. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "depth": {
      "type": "number"
    },
    "variant": {
      "type": "string"
    }
  }
}
    arguments 11 lines
  • chess_make_move unknown never probed

    [DEPRECATED — use play_apply_move] Apply a move to a chess game. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "required": [
    "move"
  ],
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  }
}
    arguments 14 lines
  • chess_validate_move reads unknown never probed

    [DEPRECATED — use play_validate_move] Check if a chess move is legal. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "required": [
    "move"
  ],
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  }
}
    arguments 14 lines
  • chess_make_moves changes data unknown never probed

    [DEPRECATED — use play_make_moves] Apply a sequence of chess moves. Removal: v1.0.0.

    mcp-tool

    {
  "type": "object",
  "required": [
    "moves"
  ],
  "properties": {
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "variant": {
      "type": "string"
    }
  }
}
    arguments 17 lines
  • chess_get_opening_book reads unknown never probed

    [REMOVED — engine#98] Opening book resolution is broken in Worker context. No replacement.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}
    arguments 8 lines
  • hex_list_games reads unknown never probed

    List all available hex map game types with configuration options

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • hex_generate_map reads unknown never probed

    Generate a hex map for a specific game and player count

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type (nukes, colony, catan, age-of-steam, eclipse, twilight-imperium)"
    },
    "seed": {
      "type": "string",
      "description": "Random seed for reproducibility"
    },
    "size": {
      "type": "number",
      "description": "Map size (default: game default)"
    },
    "players": {
      "type": "number",
      "description": "Number of players (default: 2)"
    }
  }
}
    arguments 24 lines
  • hex_export_svg unknown never probed

    Generate a hex map and export as SVG

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type"
    },
    "seed": {
      "type": "string",
      "description": "Random seed"
    },
    "size": {
      "type": "number",
      "description": "Map size"
    },
    "style": {
      "type": "string",
      "description": "Visual style"
    },
    "hexSize": {
      "type": "number",
      "description": "Hex size in pixels (default: 30)"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    }
  }
}
    arguments 32 lines
  • hex_get_info unknown never probed

    Get info about a specific hex coordinate (terrain, neighbours, distance)

    mcp-tool

    {
  "type": "object",
  "required": [
    "q",
    "r"
  ],
  "properties": {
    "q": {
      "type": "number",
      "description": "Hex Q coordinate (column)"
    },
    "r": {
      "type": "number",
      "description": "Hex R coordinate (row)"
    },
    "game": {
      "type": "string",
      "description": "Game context for terrain lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed (to look up terrain from a generated map)"
    }
  }
}
    arguments 25 lines
  • hex_compute_fov reads unknown never probed

    Compute field of view from a hex position

    mcp-tool

    {
  "type": "object",
  "required": [
    "q",
    "r",
    "range"
  ],
  "properties": {
    "q": {
      "type": "number",
      "description": "Origin Q coordinate"
    },
    "r": {
      "type": "number",
      "description": "Origin R coordinate"
    },
    "game": {
      "type": "string",
      "description": "Game context for obstacle lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    },
    "range": {
      "type": "number",
      "description": "Vision range in hexes"
    }
  }
}
    arguments 30 lines
  • hex_pathfind unknown never probed

    Find shortest path between two hex coordinates

    mcp-tool

    {
  "type": "object",
  "required": [
    "startQ",
    "startR",
    "endQ",
    "endR"
  ],
  "properties": {
    "endQ": {
      "type": "number",
      "description": "End Q"
    },
    "endR": {
      "type": "number",
      "description": "End R"
    },
    "game": {
      "type": "string",
      "description": "Game context for movement costs"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    },
    "startQ": {
      "type": "number",
      "description": "Start Q"
    },
    "startR": {
      "type": "number",
      "description": "Start R"
    }
  }
}
    arguments 35 lines
  • play_list_families unknown never probed

    List all playable game families supported by the engine (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • play_list_variants reads unknown never probed

    List available variants for a game family. Each variant can be passed to play_create_game. Variants with flags (e.g. +random) can be requested as "slug+flag".

    mcp-tool

    {
  "type": "object",
  "required": [
    "family"
  ],
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    }
  }
}
    arguments 12 lines
  • play_get_definition unknown never probed

    Get the full engine definition (topology, render config, pieces, setup FEN) for a game variant. Returns the resolved frontmatter used to render and play the game.

    mcp-tool

    {
  "type": "object",
  "required": [
    "family"
  ],
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  }
}
    arguments 16 lines
  • play_create_game changes data unknown never probed

    Create a new game instance for a given family. Returns initial state to pass to subsequent calls. Variant can include flags like "grand+random" or "standard+drops".

    mcp-tool

    {
  "type": "object",
  "required": [
    "family"
  ],
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family name (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "rngSeed": {
      "type": "number",
      "description": "Optional RNG seed for deterministic games"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug, optionally with flags (e.g. \"grand\", \"grand+random\", \"standard+drops\")"
    }
  }
}
    arguments 20 lines
  • play_get_moves reads unknown never probed

    Get all legal moves for the current position. Requires state from play_create_game or play_apply_move.

    mcp-tool

    {
  "type": "object",
  "required": [
    "state"
  ],
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object returned by play_create_game or play_apply_move"
    }
  }
}
    arguments 12 lines
  • play_apply_move changes data unknown never probed

    Apply a move to the game and return the new state. Pass the move object exactly as returned by play_get_moves (format varies by family: chess uses {from,to}, go uses {coord} or {action:"pass"}).

    mcp-tool

    {
  "type": "object",
  "required": [
    "state",
    "move"
  ],
  "properties": {
    "move": {
      "type": "object",
      "description": "Move object from play_get_moves (e.g. {from:\"e2\",to:\"e4\"} for chess, {coord:40} for go, {action:\"pass\"})"
    },
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or a previous play_apply_move"
    }
  }
}
    arguments 17 lines
  • play_check_status unknown never probed

    Check the current game status: whose turn it is, whether the game is over, and who won.

    mcp-tool

    {
  "type": "object",
  "required": [
    "state"
  ],
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  }
}
    arguments 12 lines
  • play_suggest_move reads unknown never probed

    Use AI to analyse the position and suggest the best move. Supports 5 difficulty levels across all 10 playable families.

    mcp-tool

    {
  "type": "object",
  "required": [
    "state"
  ],
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "difficulty": {
      "enum": [
        "beginner",
        "easy",
        "medium",
        "hard",
        "expert"
      ],
      "type": "string",
      "description": "AI difficulty level (default: medium)"
    }
  }
}
    arguments 23 lines
  • play_render_board unknown never probed

    Render the current board position as SVG for any playable family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

    mcp-tool

    {
  "type": "object",
  "required": [
    "state"
  ],
  "properties": {
    "size": {
      "type": "integer",
      "description": "Board width in pixels for PNG output (default: 480, max: 2048)"
    },
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "key": {
            "type": "integer"
          },
          "color": {
            "type": "string"
          }
        }
      },
      "description": "Optional cells to highlight (e.g. [{key: 52, color: \"#ff0\"}])"
    }
  }
}
    arguments 31 lines
  • play_export_fen unknown never probed

    Export the current board position as a FEN-style notation string. Works for all 10 families (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

    mcp-tool

    {
  "type": "object",
  "required": [
    "state"
  ],
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  }
}
    arguments 12 lines
  • play_load_fen unknown never probed

    Create a game state from a FEN-style position string. Works for all 10 families.

    mcp-tool

    {
  "type": "object",
  "required": [
    "family",
    "fen"
  ],
  "properties": {
    "fen": {
      "type": "string",
      "description": "Position string in FEN-style notation for the family"
    },
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Optional variant slug"
    }
  }
}
    arguments 21 lines
  • play_validate_move unknown never probed

    Check whether a move is legal in the current position without applying it. Pass the move object in the same format as play_get_moves returns.

    mcp-tool

    {
  "type": "object",
  "required": [
    "state",
    "move"
  ],
  "properties": {
    "move": {
      "type": "object",
      "description": "Move object to validate (same format as play_get_moves output)"
    },
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  }
}
    arguments 17 lines
  • play_make_moves changes data unknown never probed

    Apply a sequence of moves to a game and return the final state. Stops at the first illegal move. Move objects must match play_get_moves format.

    mcp-tool

    {
  "type": "object",
  "required": [
    "state",
    "moves"
  ],
  "properties": {
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Array of move objects in the format returned by play_get_moves"
    },
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  }
}
    arguments 20 lines
  • rules_list_games unknown never probed

    List all available game rulebooks with metadata (players, duration, complexity, mechanics). Filterable by type, complexity, and mechanics.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "status": {
      "enum": [
        "live",
        "alpha",
        "playtest"
      ],
      "type": "string",
      "description": "Filter by status (default: all)"
    },
    "category": {
      "type": "string",
      "description": "Filter by type (standalone, hub, classic, rpg, component, platform, mod, game)"
    },
    "mechanic": {
      "type": "string",
      "description": "Filter by mechanic (e.g. dice, capture, hex, oracle, narrative)"
    },
    "complexity": {
      "enum": [
        "simple",
        "moderate",
        "complex"
      ],
      "type": "string",
      "description": "Filter by complexity level"
    }
  }
}
    arguments 31 lines
  • rules_get_variant_list reads unknown never probed

    List all variants for a game with structured metadata (players, board, playable status, topology, engine config). Much richer than parsing the rulebook.

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, draughts)"
    },
    "playable": {
      "type": "boolean",
      "description": "Filter to only engine-playable variants"
    },
    "topology": {
      "type": "string",
      "description": "Filter by board topology (grid, hex, track, graph, tableau)"
    }
  }
}
    arguments 20 lines
  • rules_get_diagram reads unknown never probed

    Get board diagram SVG URL for a game variant. Returns the diagram path, topology, and rendering metadata.

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game family slug (e.g. chess, go, agon)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  }
}
    arguments 16 lines
  • rules_get_variant unknown never probed

    Get rules for a specific game variant

    mcp-tool

    {
  "type": "object",
  "required": [
    "game",
    "variant"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug"
    }
  }
}
    arguments 17 lines
  • rules_search unknown never probed

    Full-text search across all published rulebooks. Returns section-typed results with deep-link anchors.

    mcp-tool

    {
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Limit to specific game slug"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    },
    "query": {
      "type": "string",
      "description": "Search query"
    },
    "sectionType": {
      "type": "string",
      "description": "Filter by section type (general, board, pieces, setup, movement, capture, winning, special, variants)"
    }
  }
}
    arguments 24 lines
  • rules_random reads unknown never probed

    Get a random game suggestion from the library

    mcp-tool

    {
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players available"
    },
    "maxDuration": {
      "type": "number",
      "description": "Maximum game duration in minutes"
    }
  }
}
    arguments 13 lines
  • board_gallery_get reads unknown never probed

    Get details of a specific board layout by ID

    mcp-tool

    {
  "type": "object",
  "required": [
    "board"
  ],
  "properties": {
    "board": {
      "type": "string",
      "description": "Board ID or name"
    }
  }
}
    arguments 12 lines
  • tile_gallery_search reads unknown never probed

    Search hex tile sets by name, game, or terrain type

    mcp-tool

    {
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (omit to list all)"
    }
  }
}
    arguments 9 lines
  • tile_gallery_get unknown never probed

    Get details of a specific tile set with all tile types

    mcp-tool

    {
  "type": "object",
  "required": [
    "set"
  ],
  "properties": {
    "set": {
      "type": "string",
      "description": "Tile set ID or name"
    }
  }
}
    arguments 12 lines
  • tile_gallery_stats unknown never probed

    Get statistics about available tile sets

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • piece_gallery_search reads unknown never probed

    Search the piece set gallery by name, style, or game type

    mcp-tool

    {
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    },
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"staunton\", \"pixel\", \"shogi\")"
    },
    "family": {
      "type": "string",
      "description": "Filter by game family (chess, shogi, xiangqi, draughts, go, etc)"
    }
  }
}
    arguments 20 lines
  • piece_gallery_get_set unknown never probed

    Get full details and piece list for a specific set

    mcp-tool

    {
  "type": "object",
  "required": [
    "set"
  ],
  "properties": {
    "set": {
      "type": "string",
      "description": "Set name or ID"
    }
  }
}
    arguments 12 lines
  • piece_gallery_stats unknown never probed

    Get statistics about the piece gallery (total sets, styles, authors, game families)

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • oracle_list_games reads unknown never probed

    List all supported RPG systems with oracle tables and entity data availability

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • rpg_chargen unknown never probed

    Generate a random character for an RPG system (D&D 5e, Pathfinder, Ironsworn, Cairn, Knave, etc)

    mcp-tool

    {
  "type": "object",
  "required": [
    "system"
  ],
  "properties": {
    "class": {
      "type": "string",
      "description": "Class preference (omit for random)"
    },
    "level": {
      "type": "number",
      "description": "Character level (default: 1)"
    },
    "system": {
      "type": "string",
      "description": "RPG system (dnd-5e, pathfinder-1e, ironsworn, starforged, cairn, knave, maze-rats, dungeon-world)"
    }
  }
}
    arguments 20 lines
  • oracle_roll reads unknown never probed

    Roll on a random oracle table (Ironsworn, Starforged, Maze Rats, etc)

    mcp-tool

    {
  "type": "object",
  "required": [
    "system"
  ],
  "properties": {
    "table": {
      "type": "string",
      "description": "Specific table name (omit for random)"
    },
    "system": {
      "type": "string",
      "description": "RPG system slug (ironsworn, starforged, maze-rats, cairn, knave, fate-core)"
    }
  }
}
    arguments 16 lines
  • oracle_list_tables unknown never probed

    List available oracle tables for a system

    mcp-tool

    {
  "type": "object",
  "required": [
    "system"
  ],
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug"
    }
  }
}
    arguments 12 lines
  • oracle_ask unknown never probed

    Ask the oracle a yes/no question with likelihood modifier

    mcp-tool

    {
  "type": "object",
  "required": [
    "question"
  ],
  "properties": {
    "question": {
      "type": "string",
      "description": "Yes/no question"
    },
    "likelihood": {
      "enum": [
        "certain",
        "likely",
        "even",
        "unlikely",
        "impossible"
      ],
      "type": "string",
      "description": "How likely is yes? (default: even)"
    }
  }
}
    arguments 23 lines
  • oracle_scene unknown never probed

    Generate a scene using oracle tables. With a recipe, rolls each table in the recipe, resolves cross-references, and composes a narrative sentence. Without, picks random tables.

    mcp-tool

    {
  "type": "object",
  "properties": {
    "type": {
      "enum": [
        "location",
        "npc",
        "event",
        "combat"
      ],
      "type": "string",
      "description": "Scene type for random mode (default: event)"
    },
    "recipe": {
      "type": "string",
      "description": "Recipe ID (from oracle_list_recipes) — rolls each table in the recipe"
    },
    "region": {
      "enum": [
        "terminus",
        "outlands",
        "expanse"
      ],
      "type": "string",
      "description": "Region for Starforged region-aware recipes"
    },
    "system": {
      "type": "string",
      "description": "RPG system slug (default: ironsworn)"
    }
  }
}
    arguments 32 lines
  • rpg_search_entities unknown never probed

    Search RPG entities (spells, monsters, classes, items) across all systems

    mcp-tool

    {
  "type": "object",
  "required": [
    "query"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    },
    "query": {
      "type": "string",
      "description": "Search term"
    },
    "system": {
      "type": "string",
      "description": "Limit to system (dnd-5e, pathfinder-1e, etc)"
    },
    "category": {
      "type": "string",
      "description": "Entity category (spell, monster, class, item)"
    }
  }
}
    arguments 28 lines
  • rpg_get_entity reads unknown never probed

    Get full details of a specific RPG entity by name

    mcp-tool

    {
  "type": "object",
  "required": [
    "name"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "name": {
      "type": "string",
      "description": "Entity name"
    },
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "category": {
      "type": "string",
      "description": "Category filter (spells, monsters, classes, etc)"
    }
  }
}
    arguments 24 lines
  • rpg_random_encounter reads unknown never probed

    Generate a random encounter for a system and difficulty level

    mcp-tool

    {
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "description": "Monster type filter (beast, undead, fiend, dragon, etc)"
    },
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    },
    "difficulty": {
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "type": "string",
      "description": "Encounter difficulty"
    }
  }
}
    arguments 23 lines
  • rpg_browse_category reads unknown never probed

    Browse entities by category with pagination

    mcp-tool

    {
  "type": "object",
  "required": [
    "system",
    "category"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "page": {
      "type": "number",
      "description": "Page number (default 1)"
    },
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "category": {
      "type": "string",
      "description": "Category (spell, monster, class, item, feat, etc)"
    },
    "pageSize": {
      "type": "number",
      "description": "Items per page (default 20)"
    }
  }
}
    arguments 29 lines
  • rpg_loot reads unknown never probed

    Generate random loot/treasure for a system and tier

    mcp-tool

    {
  "type": "object",
  "properties": {
    "tier": {
      "enum": [
        "minor",
        "major",
        "legendary"
      ],
      "type": "string",
      "description": "Loot tier (default: minor)"
    },
    "count": {
      "type": "number",
      "description": "Number of items (default 3)"
    },
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    }
  }
}
    arguments 22 lines
  • oracle_list_recipes unknown never probed

    List all predefined scene recipes — curated multi-table compositions that produce coherent narrative prompts

    mcp-tool

    {
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Filter by game system (omit for all)"
    }
  }
}
    arguments 9 lines
  • oracle_interpret unknown never probed

    Resolve oracle cross-references. Given a result like "Action + Theme", follows references and returns expanded results

    mcp-tool

    {
  "type": "object",
  "required": [
    "result"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    },
    "result": {
      "type": "string",
      "description": "Oracle result text to interpret"
    },
    "source_table": {
      "type": "string",
      "description": "Table ID the result came from"
    }
  }
}
    arguments 20 lines
  • oracle_table_view reads unknown never probed

    View the complete contents of an oracle table — all entries with roll ranges

    mcp-tool

    {
  "type": "object",
  "required": [
    "table"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    },
    "table": {
      "type": "string",
      "description": "Table ID to view"
    }
  }
}
    arguments 16 lines
  • oracle_encounter reads unknown never probed

    Generate a tabletop RPG encounter with CR-appropriate monsters, terrain, and loot (D&D 5e or Pathfinder 1e)

    mcp-tool

    {
  "type": "object",
  "properties": {
    "system": {
      "enum": [
        "dnd-5e",
        "pathfinder-1e"
      ],
      "type": "string",
      "description": "Game system (default: dnd-5e)"
    },
    "terrain": {
      "type": "string",
      "description": "Terrain type (omit for random)"
    },
    "difficulty": {
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "type": "string",
      "description": "Encounter difficulty (default: medium)"
    },
    "party_size": {
      "type": "number",
      "description": "Number of players 1-10 (default: 4)"
    },
    "party_level": {
      "type": "number",
      "description": "Average party level 1-20 (default: 5)"
    },
    "monster_type": {
      "type": "string",
      "description": "Filter by type (undead, dragon, beast, etc)"
    }
  }
}
    arguments 39 lines
  • rpg_list_categories unknown never probed

    List entity categories for an RPG system (spells, monsters, classes, equipment, etc)

    mcp-tool

    {
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug (omit for all systems)"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    }
  }
}
    arguments 13 lines
  • game_deck_create unknown never probed

    Create, shuffle, and optionally draw/deal from a card deck

    mcp-tool

    {
  "type": "object",
  "properties": {
    "draw": {
      "type": "number",
      "description": "Number of cards to draw"
    },
    "type": {
      "enum": [
        "standard-52",
        "bavarian-32",
        "hanafuda-48",
        "mahjong-136",
        "dominoes-28",
        "standard-dice"
      ],
      "type": "string",
      "description": "Deck type (default: standard-52)"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    }
  }
}
    arguments 29 lines
  • game_deck_list_types reads unknown never probed

    List all available deck types with metadata

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • game_deck_deal unknown never probed

    Shuffle and deal a custom deck of arbitrary named cards

    mcp-tool

    {
  "type": "object",
  "required": [
    "cards"
  ],
  "properties": {
    "draw": {
      "type": "number",
      "description": "Draw N cards from the top instead of dealing hands"
    },
    "cards": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name"
        ],
        "properties": {
          "name": {
            "type": "string"
          },
          "quantity": {
            "type": "number",
            "default": 1
          }
        }
      },
      "description": "Cards in the deck (name + optional quantity)"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands (default: 1 = draw pile only)"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    }
  }
}
    arguments 39 lines
  • game_score_tracker unknown never probed

    Track scores for players in any game

    mcp-tool

    {
  "type": "object",
  "required": [
    "players"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game name"
    },
    "scores": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Scores (default: all 0)"
    },
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    }
  }
}
    arguments 26 lines
  • talisman_draw_characters reads unknown never probed

    Draw random characters from the Talisman 4e (revised) base set for a character lottery

    mcp-tool

    {
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of characters to draw (2-6, default: 4)"
    }
  }
}
    arguments 9 lines
  • talisman_draw_encounter unknown never probed

    Draw a random encounter for a Talisman ring (outer, middle, inner, crown)

    mcp-tool

    {
  "type": "object",
  "properties": {
    "ring": {
      "enum": [
        "outer",
        "middle",
        "inner",
        "crown"
      ],
      "type": "string",
      "description": "Ring to draw from (default: outer)"
    }
  }
}
    arguments 15 lines
  • jam_timer reads unknown never probed

    Get time remaining in the current Mod Jam

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • jam_vote unknown never probed

    Get voting status for the current Mod Jam

    mcp-tool

    {
  "type": "object",
  "properties": {}
}
    arguments 4 lines
  • dice_roll reads unknown never probed

    Roll dice using standard notation (e.g. 2d6+3, 4d8, d20). Supports comma-separated pools and keep-high/low (4d6kh3).

    mcp-tool

    {
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of times to roll (default 1)"
    },
    "notation": {
      "type": "string",
      "description": "Dice notation (e.g. 2d6+3, 4d6kh3, 3d8,1d12+2)"
    },
    "expression": {
      "type": "string",
      "description": "Alias for notation"
    }
  }
}
    arguments 17 lines
  • coin_flip unknown never probed

    Flip one or more coins, or pick from a list of choices

    mcp-tool

    {
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of coins (default 1)"
    },
    "choices": {
      "type": "string",
      "description": "Comma-separated options to pick from (overrides coin flip)"
    }
  }
}
    arguments 13 lines
  • team_split unknown never probed

    Randomly divide players into teams

    mcp-tool

    {
  "type": "object",
  "required": [
    "players"
  ],
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of teams (default 2)"
    },
    "teams": {
      "type": "number",
      "description": "Alias for count"
    },
    "members": {
      "type": "string",
      "description": "Comma-separated names (alternative to array)"
    },
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    }
  }
}
    arguments 27 lines
  • random_player_order unknown never probed

    Randomise turn order for a list of players

    mcp-tool

    {
  "type": "object",
  "required": [
    "players"
  ],
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    }
  }
}
    arguments 15 lines
  • timer_suggest unknown never probed

    Suggest time controls for a game based on player count and complexity

    mcp-tool

    {
  "type": "object",
  "required": [
    "game"
  ],
  "properties": {
    "game": {
      "type": "string",
      "description": "Game name"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    }
  }
}
    arguments 16 lines
  • game_jam_theme unknown never probed

    Generate a random game jam theme combining mechanics and themes

    mcp-tool

    {
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of themes to generate (default 3)"
    }
  }
}
    arguments 9 lines
  • dice_odds unknown never probed

    Calculate probability of meeting a target with a dice expression. Supports keep-high/low (4d6kh3).

    mcp-tool

    {
  "type": "object",
  "required": [
    "expression",
    "target"
  ],
  "properties": {
    "target": {
      "type": "number",
      "description": "Target number to meet or exceed"
    },
    "comparison": {
      "enum": [
        ">=",
        ">",
        "<=",
        "<",
        "="
      ],
      "type": "string",
      "description": "Comparison (default >=)"
    },
    "expression": {
      "type": "string",
      "description": "Dice expression (e.g. 2d6, 4d6kh3)"
    }
  }
}
    arguments 28 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/ebdbbab6eb16c72b/badge.svg)](https://brick.blue/agent/ebdbbab6eb16c72b)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Own the domain? Prove it and the listing carries a verified badge here too: passport.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.