game-theory-mcp
An MCP server that gives an LLM exact game-theoretic computation — equilibrium solving, dominance analysis, and structural classification of strategic interactions, computed rather than estimated.
Power your agent
Install from the publisher. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
No packaged release in the registry yet. Follow the repository README.
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchFrom the publisher
An MCP server that gives an LLM exact game-theoretic computation — equilibrium solving, dominance analysis, and structural classification of strategic interactions, computed rather than estimated.
MCP server that computes exact game-theoretic answers for LLMs — Nash equilibria, dominance, subgame perfection, and repeated-game thresholds. Written in Rust: no network, no keys, no state.
Written in Rust. No network calls, no API keys, no stored state.
Ask a language model whether a pricing scheme invites a race to the bottom, or whether a game economy rewards an exploit, and you usually get plausible strategic advice assembled from prose. Sometimes it is right. There is no way to tell from the answer.
Game theory has exact answers to a lot of those questions. This server computes them, so the model reasons from a derivation instead of a recollection.
The server never reads natural language, and the model never does the arithmetic.
The model formalizes the scenario into a Game JSON object — who the players are, what they can do, what each outcome is worth to each of them. The server checks that object and returns exact answers with the reasoning that produced them. So the parts that need judgment stay with the model, and the parts that need to be right stay in Rust.
That division is also what keeps the determinism claim true: same game in, same answer out, every time.
v0.1.0, published. The v1.0 surface is complete: every solver
game-theory-core implements is exposed as an MCP tool, alongside the concept
resources and formalization prompts.
game-theory-core handles strategic-form (simultaneous-move) games:
and extensive-form (sequential) games:
and infinitely repeated games: grim trigger with Nash reversion, returning the exact critical discount factor above which a target profile is sustainable.
game-theory-mcp serves all nine tools over stdio, plus six gt://concepts/*
resources and three formalization prompts. Mechanism design — second-price
auctions, VCG — and games of incomplete information come next.
cargo install game-theory-mcp
Point an MCP client at the installed binary:
{ "mcpServers": { "game-theory": { "command": "game-theory-mcp" } } }
To run from a checkout instead, cargo build --release -p game-theory-mcp and
point the client at target/release/game-theory-mcp.
A game with no equilibrium under the requested concept returns an empty list, not an error. A malformed game comes back as a tool result carrying diagnostics and a suggested fix, not as a protocol error — the model is the one that has to correct it, so it needs to be able to read it.
Six concept resources at gt://concepts/{nash, dominance, subgame-perfect, mixed-strategies, archetypes, repeated-games} explain each concept in the terms
the tools use and name the tool that computes it, with textbook citations.
Three prompts — formalize_scenario, analyze_competitive_dynamic,
design_incentive_scheme — guide the host model through turning a situation
into a game: picking players, enumerating strategies, deciding whether payoffs
are ordinal or cardinal. The server never parses prose; it does the arithmetic
once the model has formalized the problem.
Payoffs arrive as f64 and are converted to exact rationals during validation.
Every comparison and every solve is exact.
There is no epsilon and no tolerance parameter, so no strategy is ever "almost" dominated and no player "almost" indifferent. Mixed equilibria are reported as fractions: Battle of the Sexes gives 2/3 and 1/3, not 0.6666666666666666. This is what makes agreement with published textbook answers a real test rather than an approximate one.
Answers state their own scope rather than overreaching:
cargo test --workspace # 304 unit + 16 property + 16 end-to-end + 1 fixture + 3 doc
cargo clippy --all-targets --all-features -- -D warnings
cargo fmt --all --check
The workspace requires Rust 1.88, set once in [workspace.package],
inherited by both crates and enforced by a CI leg that checks the whole
workspace on that exact toolchain. The floor comes from rmcp 3.x; nothing in
game-theory-core's mathematics needs a compiler that new, but a single number
is one fewer thing to keep in step.
Cargo.lock is committed, so dependency changes appear as an explicit diff
under review.
Start at docs/README.md.
docs/reference/product-spec-source.md
— the original product specification, plus §7, the running record of where the
delivered design departs from it and why.docs/reference/bonanno-concept-map.md
— each solver mapped to its textbook chapter and page.Solution concepts follow Giacomo Bonanno, Game Theory: An open access textbook with 165 solved exercises, University of California Davis, 2015, available from the author: http://www.econ.ucdavis.edu/faculty/bonanno/.
Solvers are tested against that book's published exercise answers, cited by page so anyone with a copy can check the work. Where it has no chapter on a topic — repeated games, notably — the source used is named instead of implied.
MIT — see LICENSE.
The Bonanno textbook cited above is a separate third-party work under its own terms and is not distributed here.
MCP server that computes exact game-theoretic answers for LLMs — Nash equilibria, dominance, subgame perfection, and repeated-game thresholds. Written in Rust: no network, no keys, no state.
Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
No required environment variable is listed on this record.
Game Theory runs locally over stdio.
Last checked 2026-10-26. MCP server that computes exact game-theoretic answers for LLMs — Nash equilibria, dominance, subgame perfection, and repeated-game thresholds. Written in Rust: no network, no keys, no state.