Moddable Games Tools
15 tools for chess variant analysis, hex map generation, and board game utilities
Should I use this
Quality & Safety
Findings (7)
- LOWTool 'oracle_roll' description lacks action verbin oracle_roll
- LOWTool 'oracle_ask' description lacks action verbin oracle_ask
- LOWTool 'rpg_browse_category' description lacks action verbin rpg_browse_category
- LOWTool 'oracle_interpret' description lacks action verbin oracle_interpret
- LOWTool 'oracle_table_view' description lacks action verbin oracle_table_view
- LOWTool 'game_deck_deal' description lacks action verbin game_deck_deal
- LOWTool 'dice_roll' description lacks action verbin dice_roll
Based on automated analysis of tool definitions and protocol compliance.
Context Cost
This is the approximate number of tokens consumed each time the server's tools are loaded into a model's context. Higher counts reduce the attention available for other tasks.
Install
One-Click Install
Add this to your `claude_desktop_config.json` file:
{
"mcpServers": {
"moddable-games-tools": {
"url": "https://tools.moddable.games/mcp"
}
}
}Remote endpoints
https://tools.moddable.games/mcpstreamable-httpWhat it can do
Tool inventory
Tools (89)
🟢chess_generate_puzzle(variant, difficulty, theme)
Get a random chess puzzle. Filter by variant, difficulty or theme. Not every variant puzzle carries themes; use chess_list_puzzle_types to see what the pool holds.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string",
"description": "Chess variant play slug (e.g. almost-chess, benedict, fischer-random, king-of-the-hill, standard); a manifest key such as chess960 is also accepted. Returns only puzzles for this variant."
},
"difficulty": {
"type": "string",
"enum": [
"easy",
"medium",
"hard"
],
"description": "Puzzle difficulty by rating: easy under 1200, medium 1200-1799, hard 1800 and above"
},
"theme": {
"type": "string",
"description": "Puzzle theme (fork, pin, skewer, mateIn2, etc). Not every variant puzzle carries themes."
}
}
}🟢chess_list_puzzle_types
List available puzzle variants, themes, and per-variant counts from the puzzle pool
Input Schema
{
"type": "object",
"properties": {}
}🟢chess_list_variants(group)
[DEPRECATED — use play_list_variants] List chess variants. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"group": {
"type": "string"
}
}
}🟡chess_get_legal_moves(variant)
[DEPRECATED — use play_create_game + play_get_moves] Get legal moves for a chess position. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string"
}
}
}🟢chess_analyze_position(variant, depth)
[DEPRECATED — use play_suggest_move] Analyse a chess position. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string"
},
"depth": {
"type": "number"
}
}
}⚪chess_make_move(move, variant)
[DEPRECATED — use play_apply_move] Apply a move to a chess game. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"move": {
"type": "object"
},
"variant": {
"type": "string"
}
},
"required": [
"move"
]
}🟢chess_validate_move(move, variant)
[DEPRECATED — use play_validate_move] Check if a chess move is legal. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"move": {
"type": "object"
},
"variant": {
"type": "string"
}
},
"required": [
"move"
]
}🟢chess_get_status(variant)
[DEPRECATED — use play_check_status] Get chess game status. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string"
}
}
}⚪chess_render_svg(variant, fen, highlights)
[DEPRECATED — use play_render_board] Render a chess position as SVG. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string"
},
"fen": {
"type": "string",
"description": "FEN position string"
},
"highlights": {
"type": "array",
"items": {
"type": "string"
},
"description": "Squares to highlight (e.g. [\"e2\",\"e4\"])"
}
}
}⚪chess_make_moves(moves, variant)
[DEPRECATED — use play_make_moves] Apply a sequence of chess moves. Removal: v1.0.0.
Input Schema
{
"type": "object",
"properties": {
"moves": {
"type": "array",
"items": {
"type": "object"
}
},
"variant": {
"type": "string"
}
},
"required": [
"moves"
]
}🟢chess_get_opening_book(variant)
[REMOVED — engine#98] Opening book resolution is broken in Worker context. No replacement.
Input Schema
{
"type": "object",
"properties": {
"variant": {
"type": "string"
}
}
}🟢hex_list_games
List all available hex map game types with configuration options
Input Schema
{
"type": "object",
"properties": {}
}🟢hex_generate_map(game, players, size, seed)
Generate a hex map for a specific game and player count
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game type (nukes, colony, catan, age-of-steam, eclipse, twilight-imperium)"
},
"players": {
"type": "number",
"description": "Number of players (default: 2)"
},
"size": {
"type": "number",
"description": "Map size (default: game default)"
},
"seed": {
"type": "string",
"description": "Random seed for reproducibility"
}
},
"required": [
"game"
]
}⚪hex_export_svg(game, players, size, seed, style, ...)
Generate a hex map and export as SVG
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game type"
},
"players": {
"type": "number",
"description": "Number of players"
},
"size": {
"type": "number",
"description": "Map size"
},
"seed": {
"type": "string",
"description": "Random seed"
},
"style": {
"type": "string",
"description": "Visual style"
},
"hexSize": {
"type": "number",
"description": "Hex size in pixels (default: 30)"
}
},
"required": [
"game"
]
}🟢hex_get_info(q, r, game, seed)
Get info about a specific hex coordinate (terrain, neighbours, distance)
Input Schema
{
"type": "object",
"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)"
}
},
"required": [
"q",
"r"
]
}🟢hex_compute_fov(q, r, range, game, seed)
Compute field of view from a hex position
Input Schema
{
"type": "object",
"properties": {
"q": {
"type": "number",
"description": "Origin Q coordinate"
},
"r": {
"type": "number",
"description": "Origin R coordinate"
},
"range": {
"type": "number",
"description": "Vision range in hexes"
},
"game": {
"type": "string",
"description": "Game context for obstacle lookup"
},
"seed": {
"type": "string",
"description": "Map seed"
}
},
"required": [
"q",
"r",
"range"
]
}🟢hex_pathfind(startQ, startR, endQ, endR, game, ...)
Find shortest path between two hex coordinates
Input Schema
{
"type": "object",
"properties": {
"startQ": {
"type": "number",
"description": "Start Q"
},
"startR": {
"type": "number",
"description": "Start R"
},
"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"
}
},
"required": [
"startQ",
"startR",
"endQ",
"endR"
]
}🟢play_list_families
List all playable game families supported by the engine (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl)
Input Schema
{
"type": "object",
"properties": {}
}🟡play_list_variants(family)
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".
Input Schema
{
"type": "object",
"properties": {
"family": {
"type": "string",
"description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl)"
}
},
"required": [
"family"
]
}🟢play_get_definition(family, variant)
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.
Input Schema
{
"type": "object",
"properties": {
"family": {
"type": "string",
"description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl)"
},
"variant": {
"type": "string",
"description": "Variant slug (default: the family's default game)"
}
},
"required": [
"family"
]
}🟡play_create_game(family, variant, rngSeed)
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".
Input Schema
{
"type": "object",
"properties": {
"family": {
"type": "string",
"description": "Game family name (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl)"
},
"variant": {
"type": "string",
"description": "Variant slug, optionally with flags (e.g. \"grand\", \"grand+random\", \"standard+drops\")"
},
"rngSeed": {
"type": "number",
"description": "Optional RNG seed for deterministic games"
}
},
"required": [
"family"
]
}🟡play_get_moves(state)
Get all legal moves for the current position. Requires state from play_create_game or play_apply_move.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object returned by play_create_game or play_apply_move"
}
},
"required": [
"state"
]
}🟢play_apply_move(state, move)
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"}).
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or a previous play_apply_move"
},
"move": {
"type": "object",
"description": "Move object from play_get_moves (e.g. {from:\"e2\",to:\"e4\"} for chess, {coord:40} for go, {action:\"pass\"})"
}
},
"required": [
"state",
"move"
]
}🟢play_check_status(state)
Check the current game status: whose turn it is, whether the game is over, and who won.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or play_apply_move"
}
},
"required": [
"state"
]
}⚪play_suggest_move(state, difficulty)
Use AI to analyse the position and suggest the best move. Supports 5 difficulty levels across all 30 playable families.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or play_apply_move"
},
"difficulty": {
"type": "string",
"enum": [
"beginner",
"easy",
"medium",
"hard",
"expert"
],
"description": "AI difficulty level (default: medium)"
}
},
"required": [
"state"
]
}⚪play_render_board(state, highlights, size)
Render the current board position as SVG for any playable family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl).
Input Schema
{
"type": "object",
"properties": {
"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\"}])"
},
"size": {
"type": "integer",
"description": "Board width in pixels for PNG output (default: 480, max: 2048)"
}
},
"required": [
"state"
]
}⚪play_export_fen(state)
Export the current board position as a FEN-style setup string, in the form the variant's own frontmatter declares its starting position. Card, tile and dice games have no board position to export.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or play_apply_move"
}
},
"required": [
"state"
]
}🟡play_load_fen(family, fen, variant)
Create a game from a FEN-style setup string, as returned by play_export_fen. Pass the same variant the position was exported from.
Input Schema
{
"type": "object",
"properties": {
"family": {
"type": "string",
"description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game, backgammon, standard-52, bavarian-32, flower-48, double-six-dominoes, mahjong, standard-dice, agon, asalto, chaupar, dou-shou-qi, fanorona, halma, nyout, pachisi, royal-ur, senet, stern-halma, surakarta, tafl)"
},
"fen": {
"type": "string",
"description": "Position string in FEN-style notation for the family"
},
"variant": {
"type": "string",
"description": "Optional variant slug (default: the family's default game)"
}
},
"required": [
"family",
"fen"
]
}🟢play_validate_move(state, move)
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.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or play_apply_move"
},
"move": {
"type": "object",
"description": "Move object to validate (same format as play_get_moves output)"
}
},
"required": [
"state",
"move"
]
}🟢play_make_moves(state, moves)
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.
Input Schema
{
"type": "object",
"properties": {
"state": {
"type": "object",
"description": "Game state object from play_create_game or play_apply_move"
},
"moves": {
"type": "array",
"items": {
"type": "object"
},
"description": "Array of move objects in the format returned by play_get_moves"
}
},
"required": [
"state",
"moves"
]
}🟢rules_list_games(category, complexity, mechanic, status)
List all available game rulebooks with metadata (players, duration, complexity, mechanics). Filterable by type, complexity, and mechanics.
Input Schema
{
"type": "object",
"properties": {
"category": {
"type": "string",
"description": "Filter by type (standalone, hub, classic, rpg, component, platform, mod, game)"
},
"complexity": {
"type": "string",
"enum": [
"simple",
"moderate",
"complex"
],
"description": "Filter by complexity level"
},
"mechanic": {
"type": "string",
"description": "Filter by mechanic (e.g. dice, capture, hex, oracle, narrative)"
},
"status": {
"type": "string",
"enum": [
"live",
"alpha",
"playtest"
],
"description": "Filter by status (default: all)"
}
}
}🟢rules_get_game(game)
Get full rulebook content for a specific game (markdown). For metadata only, use rules_get_game_meta instead.
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game slug (e.g. chess, dnd-5e, catan)"
}
},
"required": [
"game"
]
}🟢rules_get_game_meta(game)
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.
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game slug (e.g. chess, backgammon, cairn)"
}
},
"required": [
"game"
]
}🟢rules_get_page(game, section, page)
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.
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game slug (e.g. cairn, dnd-5e)"
},
"section": {
"type": "string",
"description": "Section name (e.g. rules, classes, spells). Default: rules"
},
"page": {
"type": "string",
"description": "Page slug (e.g. character-creation, combat-and-difficulty)"
}
},
"required": [
"game",
"page"
]
}🟢rules_get_variant_list(game, playable, topology)
List all variants for a game with structured metadata (players, board, playable status, topology, engine config). Much richer than parsing the rulebook.
Input Schema
{
"type": "object",
"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)"
}
},
"required": [
"game"
]
}🟢rules_get_diagram(game, variant)
Get board diagram SVG URL for a game variant. Returns the diagram path, topology, and rendering metadata.
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game family slug (e.g. chess, go, agon)"
},
"variant": {
"type": "string",
"description": "Variant slug (default: standard)"
}
},
"required": [
"game"
]
}🟢rules_get_variant(game, variant)
Get rules for a specific game variant
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game slug"
},
"variant": {
"type": "string",
"description": "Variant slug"
}
},
"required": [
"game",
"variant"
]
}🟢rules_search(query, game, sectionType, limit)
Full-text search across all published rulebooks. Returns section-typed results with deep-link anchors.
Input Schema
{
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search query"
},
"game": {
"type": "string",
"description": "Limit to specific game slug"
},
"sectionType": {
"type": "string",
"description": "Filter by section type (general, board, pieces, setup, movement, capture, winning, special, variants)"
},
"limit": {
"type": "number",
"description": "Max results (default 10)"
}
},
"required": [
"query"
]
}🟢rules_random(players, maxDuration)
Get a random game suggestion from the library
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "number",
"description": "Number of players available"
},
"maxDuration": {
"type": "number",
"description": "Maximum game duration in minutes"
}
}
}🟢board_gallery_search(query, limit)
Search the board gallery (335 rendered board layouts across 34 game families)
Input Schema
{
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search term (e.g. \"8x8\", \"hex\", \"shogi\")"
},
"limit": {
"type": "number",
"description": "Max results (default 10)"
}
}
}🟢board_gallery_get(board)
Get details of a specific board layout by ID
Input Schema
{
"type": "object",
"properties": {
"board": {
"type": "string",
"description": "Board ID or name"
}
},
"required": [
"board"
]
}🟢tile_gallery_search(query)
Search hex tile sets by name, game, or terrain type
Input Schema
{
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search term (omit to list all)"
}
}
}🟡tile_gallery_get(set)
Get details of a specific tile set with all tile types
Input Schema
{
"type": "object",
"properties": {
"set": {
"type": "string",
"description": "Tile set ID or name"
}
},
"required": [
"set"
]
}🟢tile_gallery_stats
Get statistics about available tile sets
Input Schema
{
"type": "object",
"properties": {}
}🟢board_gallery_stats
Get statistics about the board gallery (total boards, families, topologies)
Input Schema
{
"type": "object",
"properties": {}
}🟡piece_gallery_search(query, family, limit)
Search the piece set gallery by name, style, or game type
Input Schema
{
"type": "object",
"properties": {
"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)"
},
"limit": {
"type": "number",
"description": "Max results (default 10)"
}
},
"required": [
"query"
]
}🟡piece_gallery_get_set(set)
Get full details and piece list for a specific set
Input Schema
{
"type": "object",
"properties": {
"set": {
"type": "string",
"description": "Set name or ID"
}
},
"required": [
"set"
]
}🟢piece_gallery_stats
Get statistics about the piece gallery (total sets, styles, authors, game families)
Input Schema
{
"type": "object",
"properties": {}
}🟢oracle_list_games
List all supported RPG systems with oracle tables and entity data availability
Input Schema
{
"type": "object",
"properties": {}
}⚪rpg_chargen(system, level, class)
Generate a random character for an RPG system (D&D 5e, Pathfinder, Ironsworn, Cairn, Knave, etc)
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "RPG system (dnd-5e, pathfinder-1e, ironsworn, starforged, cairn, knave, maze-rats, dungeon-world)"
},
"level": {
"type": "number",
"description": "Character level (default: 1)"
},
"class": {
"type": "string",
"description": "Class preference (omit for random)"
}
},
"required": [
"system"
]
}⚪oracle_roll(system, table)
Roll on a random oracle table (Ironsworn, Starforged, Maze Rats, etc)
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "RPG system slug (ironsworn, starforged, maze-rats, cairn, knave, fate-core)"
},
"table": {
"type": "string",
"description": "Specific table name (omit for random)"
}
},
"required": [
"system"
]
}🟢oracle_list_tables(system)
List available oracle tables for a system
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "RPG system slug"
}
},
"required": [
"system"
]
}⚪oracle_ask(question, likelihood)
Ask the oracle a yes/no question with likelihood modifier
Input Schema
{
"type": "object",
"properties": {
"question": {
"type": "string",
"description": "Yes/no question"
},
"likelihood": {
"type": "string",
"enum": [
"certain",
"likely",
"even",
"unlikely",
"impossible"
],
"description": "How likely is yes? (default: even)"
}
},
"required": [
"question"
]
}⚪oracle_scene(system, recipe, region, type)
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.
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "RPG system slug (default: ironsworn)"
},
"recipe": {
"type": "string",
"description": "Recipe ID (from oracle_list_recipes) — rolls each table in the recipe"
},
"region": {
"type": "string",
"enum": [
"terminus",
"outlands",
"expanse"
],
"description": "Region for Starforged region-aware recipes"
},
"type": {
"type": "string",
"enum": [
"location",
"npc",
"event",
"combat"
],
"description": "Scene type for random mode (default: event)"
}
}
}🟢rpg_search_entities(query, system, game, category, limit)
Search RPG entities (spells, monsters, classes, items) across all systems
Input Schema
{
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "Search term"
},
"system": {
"type": "string",
"description": "Limit to system (dnd-5e, pathfinder-1e, etc)"
},
"game": {
"type": "string",
"description": "Alias for system"
},
"category": {
"type": "string",
"description": "Entity category (spell, monster, class, item)"
},
"limit": {
"type": "number",
"description": "Max results (default 10)"
}
},
"required": [
"query"
]
}🟢rpg_get_entity(name, system, game, category)
Get full details of a specific RPG entity by name
Input Schema
{
"type": "object",
"properties": {
"name": {
"type": "string",
"description": "Entity name"
},
"system": {
"type": "string",
"description": "System slug"
},
"game": {
"type": "string",
"description": "Alias for system"
},
"category": {
"type": "string",
"description": "Category filter (spells, monsters, classes, etc)"
}
},
"required": [
"name"
]
}⚪rpg_random_encounter(system, difficulty, type)
Generate a random encounter for a system and difficulty level
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "System slug (default: dnd-5e)"
},
"difficulty": {
"type": "string",
"enum": [
"easy",
"medium",
"hard",
"deadly"
],
"description": "Encounter difficulty"
},
"type": {
"type": "string",
"description": "Monster type filter (beast, undead, fiend, dragon, etc)"
}
}
}⚪rpg_browse_category(system, game, category, page, pageSize)
Browse entities by category with pagination
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "System slug"
},
"game": {
"type": "string",
"description": "Alias for system"
},
"category": {
"type": "string",
"description": "Category (spell, monster, class, item, feat, etc)"
},
"page": {
"type": "number",
"description": "Page number (default 1)"
},
"pageSize": {
"type": "number",
"description": "Items per page (default 20)"
}
},
"required": [
"system",
"category"
]
}⚪rpg_loot(system, tier, count)
Generate random loot/treasure for a system and tier
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"description": "System slug (default: dnd-5e)"
},
"tier": {
"type": "string",
"enum": [
"minor",
"major",
"legendary"
],
"description": "Loot tier (default: minor)"
},
"count": {
"type": "number",
"description": "Number of items (default 3)"
}
}
}🟢oracle_list_recipes(game)
List all predefined scene recipes — curated multi-table compositions that produce coherent narrative prompts
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Filter by game system (omit for all)"
}
}
}⚪oracle_interpret(result, source_table, game)
Resolve oracle cross-references. Given a result like "Action + Theme", follows references and returns expanded results
Input Schema
{
"type": "object",
"properties": {
"result": {
"type": "string",
"description": "Oracle result text to interpret"
},
"source_table": {
"type": "string",
"description": "Table ID the result came from"
},
"game": {
"type": "string",
"description": "Game system (default: starforged)"
}
},
"required": [
"result"
]
}🟢oracle_table_view(table, game)
View the complete contents of an oracle table — all entries with roll ranges
Input Schema
{
"type": "object",
"properties": {
"table": {
"type": "string",
"description": "Table ID to view"
},
"game": {
"type": "string",
"description": "Game system (default: starforged)"
}
},
"required": [
"table"
]
}⚪oracle_encounter(system, party_level, party_size, difficulty, monster_type, ...)
Generate a tabletop RPG encounter with CR-appropriate monsters, terrain, and loot (D&D 5e or Pathfinder 1e)
Input Schema
{
"type": "object",
"properties": {
"system": {
"type": "string",
"enum": [
"dnd-5e",
"pathfinder-1e"
],
"description": "Game system (default: dnd-5e)"
},
"party_level": {
"type": "number",
"description": "Average party level 1-20 (default: 5)"
},
"party_size": {
"type": "number",
"description": "Number of players 1-10 (default: 4)"
},
"difficulty": {
"type": "string",
"enum": [
"easy",
"medium",
"hard",
"deadly"
],
"description": "Encounter difficulty (default: medium)"
},
"monster_type": {
"type": "string",
"description": "Filter by type (undead, dragon, beast, etc)"
},
"terrain": {
"type": "string",
"description": "Terrain type (omit for random)"
}
}
}🟢rpg_list_categories(game, system)
List entity categories for an RPG system (spells, monsters, classes, equipment, etc)
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game system slug (omit for all systems)"
},
"system": {
"type": "string",
"description": "Alias for game"
}
}
}🟢rpg_random(game, system, category, count)
Get random entities from an RPG system for inspiration or encounter prep
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game system slug"
},
"system": {
"type": "string",
"description": "Alias for game"
},
"category": {
"type": "string",
"description": "Category to draw from (omit for any)"
},
"count": {
"type": "number",
"description": "Number of random picks 1-10 (default: 1)"
}
},
"required": [
"game"
]
}⚪ti4_random_factions(players, expansions)
Generate random faction assignments for Twilight Imperium 4th Edition
Input Schema
{
"type": "object",
"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"
}
},
"required": [
"players"
]
}⚪ti4_draft_factions(players, choices, expansions)
Milty-style TI4 draft with pick pools per player
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "number",
"description": "Number of players (3-8, default: 6)"
},
"choices": {
"type": "number",
"description": "Factions per player to choose from (default: 3)"
},
"expansions": {
"type": "array",
"items": {
"type": "string"
},
"description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
}
}
}🟢ti4_list_factions(expansions)
List all TI4 factions with colors, flags, and expansion info
Input Schema
{
"type": "object",
"properties": {
"expansions": {
"type": "array",
"items": {
"type": "string"
},
"description": "Filter by expansion (e.g. [\"base\",\"pok\"]). Default: all"
}
}
}⚪ti4_draw_objectives(stage, count, expansions)
Draw random public objectives for TI4
Input Schema
{
"type": "object",
"properties": {
"stage": {
"type": "number",
"enum": [
1,
2
],
"description": "Stage 1 or 2 (default: both)"
},
"count": {
"type": "number",
"description": "Number to draw (default: 5)"
},
"expansions": {
"type": "array",
"items": {
"type": "string"
},
"description": "Expansion filter"
}
}
}⚪ti4_draw_agendas(count, type, expansions)
Draw random agenda cards for TI4 political phase
Input Schema
{
"type": "object",
"properties": {
"count": {
"type": "number",
"description": "Number to draw (default: 2)"
},
"type": {
"type": "string",
"enum": [
"law",
"directive"
],
"description": "Filter by type"
},
"expansions": {
"type": "array",
"items": {
"type": "string"
},
"description": "Expansion filter"
}
}
}⚪nukes_setup_generator(players)
Generate random territory/resource setup for a Nukes game
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "number",
"description": "Number of players (2-6, default: 2)"
}
}
}⚪game_nukes_combat(attacker, defender, terrain)
Resolve a Nukes combat encounter between units
Input Schema
{
"type": "object",
"properties": {
"attacker": {
"type": "string",
"description": "Attacking unit type"
},
"defender": {
"type": "string",
"description": "Defending unit type"
},
"terrain": {
"type": "string",
"description": "Terrain type (plains, forest, mountain, urban)"
}
},
"required": [
"attacker",
"defender"
]
}🟢colony_dice_odds(numbers)
Calculate settlement dice probability for Colony/Catan-style resource numbers
Input Schema
{
"type": "object",
"properties": {
"numbers": {
"type": "string",
"description": "Settlement numbers, comma-separated (e.g. \"5,6,8,9\")"
}
},
"required": [
"numbers"
]
}🟡game_deck_create(type, draw, hands, per_hand)
Create, shuffle, and optionally draw/deal from a card deck
Input Schema
{
"type": "object",
"properties": {
"type": {
"type": "string",
"enum": [
"standard-52",
"bavarian-32",
"hanafuda-48",
"mahjong-136",
"dominoes-28",
"standard-dice"
],
"description": "Deck type (default: standard-52)"
},
"draw": {
"type": "number",
"description": "Number of cards to draw"
},
"hands": {
"type": "number",
"description": "Deal into N hands"
},
"per_hand": {
"type": "number",
"description": "Cards per hand (default: 5)"
}
}
}🟢game_deck_list_types
List all available deck types with metadata
Input Schema
{
"type": "object",
"properties": {}
}⚪game_deck_deal(cards, hands, per_hand, draw)
Shuffle and deal a custom deck of arbitrary named cards
Input Schema
{
"type": "object",
"properties": {
"cards": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": {
"type": "string"
},
"quantity": {
"type": "number",
"default": 1
}
},
"required": [
"name"
]
},
"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)"
},
"draw": {
"type": "number",
"description": "Draw N cards from the top instead of dealing hands"
}
},
"required": [
"cards"
]
}⚪game_score_tracker(players, scores, game)
Track scores for players in any game
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "array",
"items": {
"type": "string"
},
"description": "Player names"
},
"scores": {
"type": "array",
"items": {
"type": "number"
},
"description": "Scores (default: all 0)"
},
"game": {
"type": "string",
"description": "Game name"
}
},
"required": [
"players"
]
}🟡talisman_draw_characters(count)
Draw random characters from the Talisman 4e (revised) base set for a character lottery
Input Schema
{
"type": "object",
"properties": {
"count": {
"type": "number",
"description": "Number of characters to draw (2-6, default: 4)"
}
}
}⚪talisman_draw_encounter(ring)
Draw a random encounter for a Talisman ring (outer, middle, inner, crown)
Input Schema
{
"type": "object",
"properties": {
"ring": {
"type": "string",
"enum": [
"outer",
"middle",
"inner",
"crown"
],
"description": "Ring to draw from (default: outer)"
}
}
}🟢jam_status
Get the current Mod Jam status (active jam, deadline, submissions)
Input Schema
{
"type": "object",
"properties": {}
}🟢jam_timer
Get time remaining in the current Mod Jam
Input Schema
{
"type": "object",
"properties": {}
}🟢jam_vote
Get voting status for the current Mod Jam
Input Schema
{
"type": "object",
"properties": {}
}⚪dice_roll(notation, expression, count)
Roll dice using standard notation (e.g. 2d6+3, 4d8, d20). Supports comma-separated pools and keep-high/low (4d6kh3).
Input Schema
{
"type": "object",
"properties": {
"notation": {
"type": "string",
"description": "Dice notation (e.g. 2d6+3, 4d6kh3, 3d8,1d12+2)"
},
"expression": {
"type": "string",
"description": "Alias for notation"
},
"count": {
"type": "number",
"description": "Number of times to roll (default 1)"
}
}
}🟢coin_flip(count, choices)
Flip one or more coins, or pick from a list of choices
Input Schema
{
"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)"
}
}
}⚪team_split(players, members, count, teams)
Randomly divide players into teams
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "array",
"items": {
"type": "string"
},
"description": "Player names"
},
"members": {
"type": "string",
"description": "Comma-separated names (alternative to array)"
},
"count": {
"type": "number",
"description": "Number of teams (default 2)"
},
"teams": {
"type": "number",
"description": "Alias for count"
}
},
"required": [
"players"
]
}🟢random_player_order(players)
Randomise turn order for a list of players
Input Schema
{
"type": "object",
"properties": {
"players": {
"type": "array",
"items": {
"type": "string"
},
"description": "Player names"
}
},
"required": [
"players"
]
}🟢timer_suggest(game, players)
Suggest time controls for a game based on player count and complexity
Input Schema
{
"type": "object",
"properties": {
"game": {
"type": "string",
"description": "Game name"
},
"players": {
"type": "number",
"description": "Number of players"
}
},
"required": [
"game"
]
}⚪game_jam_theme(count)
Generate a random game jam theme combining mechanics and themes
Input Schema
{
"type": "object",
"properties": {
"count": {
"type": "number",
"description": "Number of themes to generate (default 3)"
}
}
}🟢dice_odds(expression, target, comparison)
Calculate probability of meeting a target with a dice expression. Supports keep-high/low (4d6kh3).
Input Schema
{
"type": "object",
"properties": {
"expression": {
"type": "string",
"description": "Dice expression (e.g. 2d6, 4d6kh3)"
},
"target": {
"type": "number",
"description": "Target number to meet or exceed"
},
"comparison": {
"type": "string",
"enum": [
">=",
">",
"<=",
"<",
"="
],
"description": "Comparison (default >=)"
}
},
"required": [
"expression",
"target"
]
}Community
Evidence