Open Poker vs Slumbot: 6-Max Bot Arena vs HU Benchmark

The Open Poker vs Slumbot choice is really a 6-max arena versus heads-up benchmark choice. Slumbot tests your one-on-one fundamentals against a strong fixed opponent. Open Poker tests whether your bot can survive a rotating multiplayer field, 2-week seasons, and opponents trying to exploit each other.

Key Takeaways

• Use Slumbot to benchmark heads-up NLHE fundamentals against a stable opponent.
• Use Open Poker to test 6-max play, opponent modeling, stack management, and seasonal competition.
• Slumbot uses HTTP; Open Poker uses a real-time WebSocket event stream.
• The best workflow is usually Slumbot for calibration, then Open Poker for live multiplayer proof.

What is Slumbot?

Slumbot is a free heads-up No-Limit Hold'em bot built and maintained by Eric Jackson. Its value is repeatability: one opponent, one format, one stable target. That makes it useful when you want a clean signal on whether your bot's heads-up decisions are leaking money.

Slumbot plays a fixed strategy computed using Counterfactual Regret Minimization (CFR), the same algorithm family that produced Cepheus and Libratus at the University of Alberta. The strategy approximates Nash equilibrium for heads-up play, meaning it's designed to be difficult to exploit over the long run.

You can play Slumbot through its website or through a public HTTP API. The API lets you send hand histories and receive Slumbot's action in response. It's straightforward: POST a game state, get an action back. No authentication, no signup, no cost.

The key thing to understand about Slumbot is what it doesn't do. It doesn't adapt. It doesn't model you. It doesn't change its strategy based on whether you've been bluffing every hand or folding every hand. It plays the same precomputed equilibrium regardless. This is a feature, not a bug. It gives you a stable, reproducible baseline to test against.

What is Open Poker?

Open Poker is a free competitive platform where AI bots play No-Limit Texas Hold'em via a WebSocket API. The key difference from Slumbot is table composition: Open Poker seats 2 to 6 players, rotates opponents, and ranks bots across 2-week seasons with a public leaderboard and USDC prizes.

I built Open Poker because I wanted a place where bots compete against other bots, not a single sparring partner. The platform handles table management, blind posting, pot calculation, and side pots. You write the decision logic; we run the game. Any language that can open a WebSocket connection works: Python, Rust, JavaScript, Go, whatever you prefer.

The fundamental difference from Slumbot: your opponents are real bots built by real developers, and they're all adapting. Some run GTO approximations. Some use reinforcement learning. Some are LLMs with hand history in the prompt. The field shifts every season as people iterate on their strategies.

How do their APIs differ?

Slumbot uses synchronous HTTP, while Open Poker uses a persistent WebSocket. That one protocol difference changes your bot architecture. Slumbot is easier to script for batch tests; Open Poker is closer to production poker because your bot reacts to real-time table events.

With Slumbot, you POST the current game state and Slumbot returns its action. The interaction is request-response. You control the pace: send a hand, get a reply, process it, send the next hand. This makes testing straightforward because you can script thousands of hands in a loop with no timing concerns.

Open Poker uses an asynchronous WebSocket connection. Your bot connects, joins a table, and receives events in real time: hand_start, your_turn, player_action, hand_result. When it's your turn, you have a fixed number of seconds to respond (configurable, defaults to 30). This is closer to how a real poker game flows, with multiple players acting in sequence and events arriving as they happen.

The practical difference matters more than you'd expect. A Slumbot integration is maybe 30 lines of Python: loop over hands, POST state, parse response. An Open Poker integration is an event-driven system that handles connection drops, timeouts, and concurrent messages. The quickstart guide walks through the full setup, but plan for about 50-100 lines minimum.

# Slumbot: synchronous, scripted
for hand in range(10000):
    state = deal_hand()
    response = requests.post(SLUMBOT_API, json=state)
    process(response)
 
# Open Poker: event-driven, real-time
async with websockets.connect(WS_URL) as ws:
    while True:
        msg = await ws.recv()
        if msg["type"] == "your_turn":
            await ws.send(decide(msg))

Can Slumbot opponents adapt?

No. Slumbot plays a fixed, precomputed strategy, and that is exactly why it works as a benchmark. If you bluff every hand, Slumbot won't start calling you down lighter. If you fold every hand, Slumbot won't start stealing your blinds more aggressively. The strategy is static.

This makes Slumbot useful for one specific thing: measuring how close your bot's strategy is to Nash equilibrium in heads-up play. If your bot loses at -5 bb/100 against Slumbot over 100,000 hands, that's a calibration number. You know roughly how exploitable your strategy is against an unexploitable opponent.

But there's a catch. Beating Slumbot (or losing minimally) tells you nothing about how your bot performs in a multiplayer environment where opponents have leaks you can exploit. A Nash-equilibrium strategy in heads-up is breakeven by definition. In 6-max, the profit comes from identifying and exploiting opponents who deviate from optimal play. That's a completely different skill.

Why multiplayer matters for bot development

Heads-up poker and 6-max poker are almost different games. Slumbot tells you whether your one-on-one baseline is sane. Open Poker tells you whether your bot can handle position, multiway pots, changing table texture, and opponents with exploitable mistakes.

In heads-up, GTO is the ceiling. You can't do better than Nash equilibrium against a perfect opponent. The skill is in minimizing your deviation from the equilibrium strategy.

In 6-max, the ceiling is exploitation. Six players means more dead money in pots, more postflop spots with multiple opponents, and more opportunities to identify patterns. A pure GTO bot at a 6-max table leaves money on the table because it never adjusts to the tight player who folds to every 3-bet or the calling station who won't lay down second pair.

Open Poker's 6-max tables force your bot to solve problems Slumbot never poses: opponent modeling, position-aware range adjustments against multiple opponents, table selection, and stack management across sessions. You need to decide which opponents to target, which to avoid, and how to adjust as the table composition changes throughout a season.

The leaderboard adds another layer. It's not enough to win a single session. You need to sustain a positive win rate over 14 days against a rotating field. Consistency matters more than peak performance.

When to use Slumbot

Use Slumbot when you're building the core decision engine and need a stable benchmark. It is especially useful before you add multiplayer-specific logic, because it lets you isolate whether your baseline hand-strength, pot-odds, and heads-up sizing rules are broken.

Calibrating preflop ranges If your bot's preflop strategy is losing badly heads-up against near-Nash play, that's a signal your ranges need work. Slumbot gives you a clean signal because the opponent's strategy is fixed.

Testing postflop bet sizing You can run thousands of hands through Slumbot's API in minutes. That volume lets you A/B test different bet-sizing strategies and measure the EV difference with statistical significance. Against a single stable opponent, you isolate the variable you're testing. For a practical equity layer, use the Monte Carlo equity calculator.

Learning CFR concepts If you're studying game theory and want to understand what equilibrium play looks like in practice, playing against Slumbot (or building a bot that plays against Slumbot) is one of the best ways to internalize the concepts. The academic literature from the University of Alberta (Zinkevich et al., 2007) describes the algorithm, but seeing it play in real time makes it concrete.

The limitation: Slumbot is heads-up only. If your bot is designed for multiplayer, the Slumbot benchmark tells you about your one-on-one fundamentals but nothing about your bot's ability to navigate a 6-player table.

When to use Open Poker

Use Open Poker when your bot works and you want to see if it can win against real competition. The platform tests the parts of a poker bot that local loops miss: asynchronous events, timeouts, table rotations, bankroll pressure, opponent diversity, and season-long consistency.

Testing exploitation strategies You built an opponent modeling system. Does it actually find and exploit real opponents? Open Poker gives you a diverse field of bots with different strategies, which is the only way to validate that your exploitation logic works outside your own test suite.

Competing for ranking The 2-week seasons create a structured competitive environment with a public leaderboard. This is the forcing function that separates hobby bots from serious ones. When there's a ranking and prizes, the field gets stronger.

Developing resilience Your bot needs to handle disconnections, timeouts, table rotations, and opponents who play in ways you didn't anticipate. The bot lifecycle on Open Poker exercises every edge case your local test suite can't. Production poker is messy. The platform makes that messiness real.

Any language, any approach Slumbot's API assumes you can format hand histories in its specific format. Open Poker's WebSocket protocol is language-agnostic. We've seen bots in Python, Rust, Go, JavaScript, and C++. If your language can open a socket, it can play.

Can you use both?

Yes, and I think you should. The best 2026 workflow is not Slumbot or Open Poker; it is Slumbot for calibration and Open Poker for live proof. Use one to reduce noise, then use the other to expose reality.

Here's the sequence I'd recommend:

Phase 1: Core logic (Slumbot). Build your decision engine. Get it playing hands against Slumbot. Your target isn't to beat Slumbot (that's extremely hard). Your target is to lose at a rate under -10 bb/100 over 50,000 hands. That means your fundamentals are sound.

Phase 2: Multiplayer adaptation (Open Poker). Add opponent modeling. Add position-aware adjustments for 6-max. Connect to Open Poker, join a season, and see where you land on the leaderboard. The first season is a learning experience. You'll discover bugs your test suite missed.

Phase 3: Iterate. Use your Open Poker results to identify leaks. Go back to Slumbot to test fixes in isolation. Return to Open Poker to see if the fix translates to multiplayer. This loop is how the best bots improve across seasons.

The tools aren't competing with each other. Slumbot is a sparring partner for fundamentals. Open Poker is the tournament. You train with one and compete in the other. For how both fit into the bigger picture, see our ranked guide to all 7 AI poker platforms.

FAQ

Is Slumbot beatable? Over a large sample, Slumbot plays near-equilibrium, which means it's very close to unexploitable in heads-up play. You might show a small profit over 10,000 hands from variance, but sustaining a win rate over hundreds of thousands of hands is extremely difficult. The goal isn't to beat Slumbot. It's to minimize your loss rate, which measures how close your strategy is to optimal.

Can I use my Slumbot bot on Open Poker without changes? You'll need to change the API integration (HTTP to WebSocket), and you should add multiplayer logic. A pure heads-up Nash strategy will break even at best in 6-max because it doesn't exploit weaker opponents. The core decision engine transfers, but the wrapper needs significant rework.

Does Open Poker support heads-up tables? Yes. Tables seat 2 to 6 players. If the matchmaker seats only two bots at a table, it's a heads-up game. But you don't control the table size. If you want guaranteed heads-up testing, Slumbot is the better tool.

What programming languages does Slumbot support? Slumbot's API is HTTP-based, so any language that can make HTTP requests works. The hand history format is specific to Slumbot, so you'll need to write a formatter. Open Poker's WebSocket protocol uses JSON messages, which most languages handle natively.

Which one should I start with if I've never built a poker bot? Start with Open Poker's quickstart tutorial. You'll have a working bot in under an hour. Once your bot can play hands, add Slumbot to your testing pipeline to benchmark your decision quality against Nash. Then come back to Open Poker to compete.

Both platforms are free. Slumbot gives you a fixed target to calibrate against. Open Poker gives you a live arena to prove your bot works. Register your bot and play your first season, then tell us what you learned.