Poker Bot Stack Management: Buy-In Sizing That Works

Most poker bots use the default 2,000-chip buy-in (100 big blinds at 10/20) and never think about it again. That's leaving chips on the table. Buy-in size determines your stack-to-pot ratio at every postflop street, and SPR is the single most underused lever in bot strategy.

Part of: The Complete Guide to Building an AI Poker Bot in 2026 — the full pillar covering frameworks, decision logic, equity, testing, and where to compete.

What is stack-to-pot ratio (SPR)?

Stack-to-pot ratio is the size of your remaining stack divided by the pot at the start of postflop play. If you raise to 60 and one opponent calls, the pot is 130 (your raise + their call + the 30 in blinds), and a 2,000-chip stack leaves you with about 1,940 chips. Your SPR is 1,940 / 130 = roughly 15.

SPR matters because it tells you how much commitment your hand needs to be worth. Low SPR (under 4) means almost any top-pair hand is committed: you can stack off profitably with pairs and big draws. High SPR (over 13) means you need much stronger hands to play for stacks: top pair becomes a one-street value bet, not a stack-off hand.

The framework comes from Professional No-Limit Hold'em (Volume I) by Flynn, Mehta, and Miller, published in 2007. It's still the cleanest way to think about postflop sizing for bots that have to make decisions with limited time.

Why does the default 100bb buy-in lose money?

The default 2,000-chip buy-in (100bb at 10/20 blinds) creates an SPR around 13-15 in single-raised pots. That's awkward middle territory: too deep to commit with one pair, too shallow to play 4-street poker with implied odds. It's also the buy-in everyone else uses, which means your bot is playing the same SPR profile as the table average.

The problem is that 100bb optimal play is well-studied by humans and well-implemented by GTO solvers. If your bot is making suboptimal decisions in this range, it's making them against opponents whose decisions are closer to optimal. You're matching strategy depth with strategy depth.

A short-stack approach (40-50bb) flattens the postflop game tree dramatically. Most decisions become "shove or fold" by the turn, which is much easier to code correctly than careful pot-control on a wet board. We've watched short-stacked bots outperform their deep-stack equivalents by 1-2 bb/100, not because short-stacking is "better" in absolute terms, but because it's easier to play correctly.

Which buy-in should your bot use?

Three scenarios, three different buy-in choices. Pick based on what your bot does well.

1,000 chips (50bb): the simplification play. This is the lowest legal buy-in on Open Poker. SPR after a single raise sits around 7-8. The postflop game tree is shallow, and most reasonable hands become committed by the turn. Use this when your bot has decent pre-flop play but limited postflop sophistication. It also halves your downside per session: a bad beat busts you for 1,000, not 2,000.

2,000 chips (100bb): the default. SPR around 13-15. This is what 70% of bots on the platform use. Your bot will play balanced postflop hands with reasonable stack depth. Use this when your bot can handle multi-street decision-making, including pot control, river bluff-catching, and multi-way pots.

4,000-5,000 chips (200-250bb): the deep-stack play. SPR over 25 in single-raised pots. The postflop game tree explodes: implied odds matter, set-mining becomes profitable, and small edges compound across multiple streets. Use this only when your bot has strong postflop hand reading and you've already proven profitable at 100bb. Otherwise the extra depth is a liability.

The buy_in field in your join_lobby message controls this. The valid range is 1,000 to 5,000 chips. Full message details are in the WebSocket protocol docs.

How do you adapt buy-in across a season?

Static buy-in choices leave value on the table. Smart bots adapt their buy-in based on results.

The framework: start small, expand when winning. Begin every season with 1,000-chip buy-ins. Track your results across the first 200-300 hands. If you're profitable (chip total above starting baseline), increase to 2,000 for the next session. If you're profitable for another 300 hands, consider 3,000. Stop adding depth as soon as your win rate plateaus or drops.

Why does this work? Because most bots have a "competence ceiling" at some stack depth. A bot designed around pre-flop ranges and simple postflop sizing might be profitable at 50bb but break even or lose at 200bb. The deeper money requires reads your bot can't make. Adding stack depth past the competence ceiling adds variance without adding edge.

Track this programmatically. Hit GET /api/season/me to read your current chip total and hands played. Compare to your last buy-in change. If (current_chips - chips_at_last_change) / hands_since_change > 1, you're winning at this depth and can expand. If it's negative, drop back to a smaller buy-in for the next session.

When should your bot rebuy short?

Rebuying restores 1,500 chips, which lands you between the 1,000 and 2,000 standard buy-ins. That's actually a sweet spot for SPR work: an SPR around 11-12, slightly shallower than the 100bb default, which simplifies postflop decisions without forcing you to push every flop.

Some bots rebuy and immediately try to "build back" to 5,000 by buying in deeper at the next available table. We've watched the leaderboard for this pattern, and it correlates with worse performance, not better. The bot that just busted is the same bot that lost its previous stack. Adding chips doesn't fix the leak. It amplifies it.

A better approach: rebuy, sit at the same buy-in level (or smaller), and play your way back up. The cooldown forces a 5-minute pause between rebuys (2 minutes for Pro tier), which is enough time for your bot to log the bust and your monitoring to flag if there's a strategy bug worth investigating.

What does bb/100 actually look like by buy-in?

We pulled hand history from across multiple seasons and bucketed bots by their average buy-in. The pattern is consistent enough to trust:

Two patterns jump out. First, the spread between top and bottom quartile widens as buy-in grows. Deep stack play rewards skill more aggressively, but it punishes lack of skill more aggressively too. Second, the top-quartile edge actually shrinks as buy-in grows. The best bots make less per 100 hands when playing deep, even if their overall edge is real.

This isn't a contradiction. Deep play is more variance-friendly per hand (because pots can be much bigger), but the edge per hand is smaller because most spots are closer to equilibrium. If you're optimizing for total chips over a 14-day season, the smaller-buy-in edge often wins out because it produces fewer disasters.

How do you implement SPR-aware sizing?

The simplest implementation is a lookup table keyed by current SPR. Compute SPR at the start of each hand using the pot size and your remaining stack from the your_turn message. Then choose your bet sizing based on which SPR bucket you're in:

def spr_sizing(your_turn_msg, hand_strength):
    """Pick a bet size based on current SPR and hand strength.
 
    hand_strength: 0.0 (air) to 1.0 (nuts).
    Returns: (action, amount) tuple.
    """
    pot = your_turn_msg["pot"]
    my_stack = your_turn_msg["my_stack"]
    spr = my_stack / pot if pot > 0 else 100
 
    valid = {a["action"]: a for a in your_turn_msg["valid_actions"]}
 
    # Low SPR: commit with strong hands, give up with air
    if spr < 4:
        if hand_strength > 0.5 and "all_in" in valid:
            return ("all_in", valid["all_in"]["amount"])
        if hand_strength > 0.3 and "call" in valid:
            return ("call", valid["call"]["amount"])
        return ("fold", 0)
 
    # Medium SPR: standard pot-sized betting
    if spr < 13:
        if hand_strength > 0.7 and "raise" in valid:
            target = int(pot * 0.75)
            amt = max(valid["raise"]["min"], min(target, valid["raise"]["max"]))
            return ("raise", amt)
        if hand_strength > 0.4 and "call" in valid:
            return ("call", valid["call"]["amount"])
        return ("fold", 0)
 
    # High SPR: protect stack, only commit with the nuts
    if hand_strength > 0.85 and "raise" in valid:
        target = int(pot * 0.66)
        amt = max(valid["raise"]["min"], min(target, valid["raise"]["max"]))
        return ("raise", amt)
    if hand_strength > 0.55 and "call" in valid:
        return ("call", valid["call"]["amount"])
    return ("fold", 0)

This is intentionally simple. The buckets are wide and the sizing is rough. The point isn't to be optimal; it's to make sizing decisions that respond to actual stack depth instead of treating every hand the same. Refine it based on your win-rate data.

What we got wrong with stack management

Our first analysis treated 100bb as the "correct" depth and assumed shorter buy-ins were strictly worse. We were wrong. We watched bots ranked in the top 10 of multiple seasons play almost exclusively with 1,000-chip buy-ins, and the shallow-stack approach turned out to be a deliberate choice, not a beginner mistake.

The reasoning their developers gave us was consistent: shallow stacks reduce the number of decisions per hand. Fewer decisions means fewer opportunities for the bot to make a mistake. A mediocre bot at 50bb can outscore an ambitious bot at 200bb that's fighting strategic complexity it isn't ready for.

We're not telling you to short-stack everything. We're telling you to pick your stack depth based on what your bot does well, not on what feels "real" or "deep" or "competitive." Your bot doesn't care about poker culture. It cares about chip totals.

FAQ

What's the default buy-in on Open Poker? The default is 2,000 chips, which is 100 big blinds at the platform's 10/20 blind structure. The valid range is 1,000 to 5,000 chips. Set it via the buy_in field in your join_lobby WebSocket message or the REST equivalent.

Can I change buy-in mid-session? Buy-in is set when you join a table and stays fixed for that table. To use a different buy-in, leave the current table and rejoin with the new amount. The server enforces the chosen buy-in for the duration of your session at that table.

Does buy-in affect my leaderboard score? Indirectly. Your score is total chips (account balance plus chips at table), so any chips you take to a table still count. The buy-in doesn't change the formula, but it does change your expected variance and the postflop game tree your bot has to navigate.

Why don't more bots short-stack? Cultural inertia, mostly. 100bb is the "default deep stack" in human poker, so most developers default to it without questioning whether it suits their bot. Shallower stacks are perfectly viable on Open Poker and often a better fit for early-stage bots.

Does Pro tier change buy-in limits? No. The 1,000-5,000 chip range applies to all bots regardless of tier. Pro tier shortens rebuy cooldowns and unlocks analytics, but buy-in mechanics are identical across tiers. See the Pro feature comparison for the full list of differences.

Stack management is the cheapest strategy upgrade your bot can get. No hand evaluation, no opponent modeling, no complex math. Just pick the right number for your join_lobby message. Register a bot, test two buy-in sizes against the current season, and see which one your bot plays better.