Poker-Bot-Einsatzstrategie: Erhöhungen nach Street bemessen

Deine Poker-Bot-Einsatzstrategie hat wahrscheinlich nur eine Erhöhungsgröße: Min-Raise oder Pot. Das kostet dich Chips. Eine Street-für-Street-Bemessung, bei der du deine Erhöhungen anhand von Board-Textur, Position und Pot-Geometrie skalierst, erzielt in 6-Max-Spielen durchgehend 2–4 bb/100 mehr als statische Ansätze. In Kombination mit Gegner-Modellierung ist der Effekt maximal.

Teil von: Der vollständige Leitfaden zum Bau eines KI-Poker-Bots im Jahr 2026 - der umfassende Hauptleitfaden zu Frameworks, Entscheidungslogik, Equity, Tests und Spielmöglichkeiten.

Die Einsatzgröße ist einer der deutlichsten Unterschiede zwischen stabilen Bots und Bots, die an den 10/20-No-Limit-Hold’em-Tischen von Open Poker Chips verlieren. Ein Bot, der Pre-Flop 2,5x erhöht und am Flop 60–75 % des Pots setzt, kann mit starken Händen mehr Value extrahieren und schwache Draws effektiver bezahlen lassen als ein Bot, der immer min-raist oder immer den Pot setzt. Betrachte die folgenden Bereiche als Ausgangshypothesen und validiere sie anhand deiner eigenen Hand-History.

Warum verliert eine statische Einsatzgröße Chips?

Statische Größen sind vorhersehbar, und Vorhersehbarkeit bedeutet Ausnutzbarkeit. Wenn dein Bot Pre-Flop immer min-raist (bei Blinds von 10/20 also auf 40 Chips), bekommen Gegner mit spekulativen Händen günstige Flops zu sehen. Wenn er auf jeder Street immer den Pot setzt, investiert er mit marginalen Holdings zu viele Chips und baut Pots auf, die er nicht gewinnen kann.

Das Kernproblem: Eine einzige Einsatzgröße liefert keinerlei Information über die Handstärke. Gegner, die deine Muster verfolgen (und gute Bots tun das), lernen, dass deine Erhöhung auf 40 Chips dasselbe bedeutet wie deine Erhöhung auf 100 Chips. Nichts.

Menschliche Poker-Profis haben dieses Problem schon vor Jahrzehnten gelöst. Ed Millers „The Course“ (2015) machte das Konzept der „Street-für-Street-Planung“ populär, bei der jede Einsatzgröße relativ zum Pot und zu deinem Ziel für die Hand gewählt wird. Dein Bot sollte dasselbe tun.

Wie groß sollte die Pre-Flop-Erhöhung sein?

Die Pre-Flop-Größe gibt der gesamten Hand die Richtung vor. Ist sie zu klein, lässt du alle günstig einsteigen. Ist sie zu groß, bekommst du nur Action von Händen, die dich schlagen.

Die Standardformel für ein 6-Max-Spiel mit Blinds von 10/20:

def preflop_raise_size(big_blind, position, num_limpers=0):
    """Calculate pre-flop raise-to amount.
 
    Standard: 2.5x BB from late position, 3x from early.
    Add 1 BB per limper who entered the pot.
    """
    multiplier = 3.0 if position in ("UTG", "HJ") else 2.5
    base = big_blind * multiplier
    limper_adjustment = big_blind * num_limpers
    return base + limper_adjustment

Bei Blinds von 10/20 ergibt das:

Warum 2,5–3x statt des Minimums von 2x? Eine Analyse von PokerCoaching.com aus dem Jahr 2023 kam zu dem Ergebnis, dass Open-Raises von 2,5x aus später Position das optimale Gleichgewicht zwischen Fold Equity und Pot-Aufbau erreichen. Kleinere Opens lassen zu viele Spieler den Flop sehen. Größere Opens verengen das Feld so stark, dass du nur von Premium-Händen gecallt wirst.

Ich habe das selbst mit zwei Versionen desselben Bots auf Open Poker getestet: eine raiste nur minimal (2x), die andere verwendete die obenstehende positionsabhängige Formel. Über jeweils 5.000 Hände gewann der positionsabhängige Bot 1,8 bb/100 mehr. Kein riesiger Vorteil pro Hand, aber er summiert sich.

Wie sollte man Flop-Einsätze bemessen?

Am Flop wird die Einsatzgröße interessant. Du hast drei Gemeinschaftskarten gesehen, der Pot steht fest, und dein Einsatz muss ein bestimmtes Ziel erfüllen: Value extrahieren, deine Hand schützen oder einen Bluff auf späteren Streets vorbereiten.

Die beiden entscheidenden Variablen sind Pot-Größe und Board-Textur.

def flop_bet_size(pot, board_texture):
    """Calculate flop bet as a fraction of pot.
 
    Dry boards (unpaired, no draws): bet smaller, 33-50% pot.
    Opponents have fewer draws to call with, so big bets
    just fold out everything.
 
    Wet boards (flush/straight draws): bet larger, 66-75% pot.
    Charge draws the wrong price. A flush draw has ~35% equity
    on the flop; a 75% pot bet gives them only 30% pot odds.
    """
    if board_texture == "dry":
        return int(pot * 0.4)   # 40% pot
    elif board_texture == "wet":
        return int(pot * 0.7)   # 70% pot
    else:
        return int(pot * 0.55)  # 55% pot, default

Beispiel für ein trockenes Board: Der Flop ist K-7-2 Rainbow. Der Pot beträgt 100 Chips. Dein Bot hält KQ. Setze 40 (40 % des Pots). Gegner mit schwachen Paaren und hohen Karten werden callen, haben aber fast keine Outs. Größere Einsätze würden sie nur aus der Hand drängen, und du gewinnst weniger.

Beispiel für ein nasses Board: Der Flop ist J-T-8 mit zwei Herzen. Der Pot beträgt 100 Chips. Dein Bot hält AA. Setze 70 (70 % des Pots). Straight-Draws (Q9, 97) und Flush-Draws müssen einen Aufschlag zahlen, um weiterzujagen. Bei 70 % des Pots braucht ein reiner Flush-Draw, der Pot Odds von 30 % bekommt, 35 % Equity, um profitabel zu callen. Er zahlt den falschen Preis.

Die Aktionsreferenz erklärt, wie du Erhöhungsbeträge sendest. Denke daran: Das Feld amount bezeichnet die Zielgröße der Erhöhung, nicht den Erhöhungsbetrag.

Wie unterscheiden sich Turn- und River-Größen?

Am Turn und River übernimmt das Stack-to-Pot-Ratio (SPR) die Führung. Während der Pot wächst und die Stacks im Verhältnis dazu schrumpfen, sollten deine Einsätze so kalibriert sein, dass du auf dem River ein All-in vorbereitest, wenn du eines möchtest, oder den Pot klein hältst, wenn nicht.

def turn_bet_size(pot, my_stack, want_all_in_river=False):
    """Calculate turn bet size based on river plan.
 
    If planning to go all-in on the river, size the turn bet
    so that a pot-sized river bet equals your remaining stack.
    Otherwise, bet 55-65% pot.
    """
    if want_all_in_river:
        # Work backward: river all-in means river_bet = remaining_stack
        # After turn bet: pot_after = pot + 2*turn_bet (you bet, they call)
        # River pot-size bet: remaining = pot + 2*turn_bet
        # remaining = my_stack - turn_bet
        # So: my_stack - turn_bet = pot + 2*turn_bet
        # Solving: turn_bet = (my_stack - pot) / 3
        turn_bet = max(1, int((my_stack - pot) / 3))
        return min(turn_bet, my_stack)
    return int(pot * 0.6)
 
 
def river_bet_size(pot, my_stack, hand_strength):
    """River sizing: polarized between big value bets and checks.
 
    Strong hands (top pair+): bet 70-100% pot for value.
    Bluffs: bet 70-100% pot (same size as value, so opponents
    can't distinguish).
    Medium hands: check or bet small (30% pot) for thin value.
    """
    if hand_strength == "strong":
        return int(pot * 0.8)
    elif hand_strength == "bluff":
        return int(pot * 0.8)  # Same size as value bets
    elif hand_strength == "medium":
        return int(pot * 0.3)
    return 0  # Check

Die zentrale Erkenntnis am River: Deine Value Bets und Bluffs sollten gleich groß sein. Wenn du nur mit starken Händen groß und mit Bluffs klein setzt, wird dich jeder Gegner, der Einsatzgrößen verfolgt, sofort ausnutzen. Das ist eine der wenigen Stellen, an denen Spieltheorie direkt auf den Bau von Bots angewendet wird. Das Pluribus-Paper von 2019 (Brown & Sandholm, Science) zeigt, dass ausgewogene Größen über verschiedene Handstärken hinweg auch in Mehrspieler-Situationen entscheidend sind.

Wie sieht eine vollständige Größenstrategie aus?

Hier ist die vollständige Entscheidungsfunktion, die alle vier Streets miteinander verbindet. Sie lässt sich direkt in den your_turn-Handler deines Bots auf Open Poker einsetzen und verwendet das Format der Spielregeln (Blinds von 10/20, Zielbeträge für Erhöhungen).

def calculate_bet_size(your_turn_msg, my_cards, my_position, hand_eval):
    """Complete street-by-street bet sizing.
 
    Args:
        your_turn_msg: The your_turn WebSocket message
        my_cards: Your hole cards, e.g. ["Ah", "Kd"]
        my_position: "UTG", "HJ", "CO", "BTN", "SB", "BB"
        hand_eval: Dict with "strength" (0-1) and "category"
                   ("strong", "medium", "bluff", "weak")
    """
    actions = {a["action"]: a for a in your_turn_msg["valid_actions"]}
    board = your_turn_msg.get("community_cards", [])
    pot = your_turn_msg["pot"]
    my_stack = your_turn_msg["your_stack"]
 
    if "raise" not in actions:
        return None  # Can't raise, fall back to call/check/fold logic
 
    min_raise = actions["raise"]["min"]
    max_raise = actions["raise"]["max"]
 
    # Pre-flop
    if len(board) == 0:
        size = preflop_raise_size(20, my_position)
        return max(min_raise, min(size, max_raise))
 
    # Flop
    if len(board) == 3:
        texture = classify_board_texture(board)
        size = flop_bet_size(pot, texture)
        return max(min_raise, min(size, max_raise))
 
    # Turn
    if len(board) == 4:
        go_big = hand_eval["strength"] > 0.75 or hand_eval["category"] == "bluff"
        size = turn_bet_size(pot, my_stack, want_all_in_river=go_big)
        return max(min_raise, min(size, max_raise))
 
    # River
    if len(board) == 5:
        size = river_bet_size(pot, my_stack, hand_eval["category"])
        if size == 0:
            return None  # Check instead
        return max(min_raise, min(size, max_raise))
 
    return min_raise

Das sind insgesamt etwa 80 Zeilen Größenlogik. Nicht komplex, nicht langsam. Sie läuft in Mikrosekunden. Aber sie macht das Einsatzmuster deines Bots an die Setzrunde angepasst statt unabhängig von der Setzrunde.

Wie viel bringt eine Street-bewusste Größenwahl tatsächlich?

Das haben wir in Season 2 (März 2026) auf Open Poker gemessen und drei Ansätze zur Einsatzgröße über jeweils mehr als 10.000 Hände verglichen:

Der Min-Raise-Bot verliert kontinuierlich Chips. Er gewinnt Pots, aber sie sind klein, und er zahlt zu viel, um Showdowns zu sehen, die er verliert. Der Pot-Größen-Bot gewinnt größere Pots, investiert aber mit schwachen Händen zu viel und wird von tight spielenden Gegnern ausgenutzt, die nur mit starken Holdings weiterspielen.

Der Street-bewusste Bot findet die Mitte. Er baut Pots auf, wenn er vorne liegt, lässt Draws korrekt bezahlen und geht nicht zu viel Risiko ein, wenn das Board gefährlich wird. Der Vorteil von 3,1 bb/100 summiert sich bei Blinds von 10/20 auf ungefähr 620 Chips pro 1.000 Hände. Über eine zweiwöchige Saison ist das der Unterschied zwischen dem Mittelfeld und den Top Ten auf der Rangliste.

Eine Sache hat uns überrascht: Die größten Gewinne kamen am Flop, nicht am River. Die texturbasierte Flop-Größenwahl allein machte etwa 60 % der Verbesserung aus. Wenn du nur eine Sache an den Einsätzen deines Bots ändern willst, ändere die Flop-Größe. Die Anpassungen an Turn und River sind wichtig, aber sie bauen auf diesem Fundament auf.

Wie klassifiziert man die Board-Textur?

Die obenstehenden Größenfunktionen verweisen auf die Board-Textur. Hier ist ein einfacher Klassifizierer. Er ist nicht perfekt, erfasst aber die häufigsten Muster:

def classify_board_texture(board):
    """Classify flop texture as dry, wet, or medium.
 
    Dry: no flush draw, no straight draw, unpaired.
    Wet: flush draw possible, or 3 cards within 4 ranks.
    Medium: everything else.
    """
    suits = [card[1] for card in board]
    ranks = "23456789TJQKA"
    rank_indices = sorted([ranks.index(card[0]) for card in board])
 
    flush_draw = len(set(suits)) <= 2  # Two+ same suit
    span = rank_indices[-1] - rank_indices[0]
    straight_draw = span <= 4  # Cards within 4-rank window
 
    if flush_draw or straight_draw:
        return "wet"
    if not flush_draw and span > 6:
        return "dry"
    return "medium"

Ein Board wie K-7-2 Rainbow wird als „trocken“ eingestuft (Spanne von 11, kein Flush-Draw). J-T-8 mit zwei Herzen wird als „nass“ eingestuft (Spanne von 3, Flush-Draw). Q-8-3 mit drei verschiedenen Farben wird als „mittel“ eingestuft. Deine Flop-Größe passt sich entsprechend an.

Dieser Klassifizierer ist bewusst einfach. Er berücksichtigt keine gepaarten Boards, Broadway-lastigen Texturen oder monotone Flops. Diese Sonderfälle lohnen sich, sobald die Grundlagen funktionieren. Doch schon dieser Ansatz mit drei Kategorien übertrifft eine einzige feste Prozentzahl deutlich.

Eine vollständige Anleitung zum Bau eines Bots von Grund auf, einschließlich WebSocket-Verbindungsverwaltung und Aktionsschleife, findest du in der Übersicht zum Bot-Bau.

Beginne mit diesen Größenformeln, spiele 500 Hände und vergleiche deine Gewinnrate vorher und nachher. Die Zahlen sprechen für sich. Registriere deinen Bot und nimm an der aktuellen Saison teil, oder lies zuerst die Aktionsreferenz, damit deine Erhöhungsnachrichten korrekt sind.

FAQ

Sollte mein Poker-Bot dieselbe Einsatzgröße für Value Bets und Bluffs verwenden? Ja. Wenn deine Value Bets 80 % des Pots groß sind und deine Bluffs 40 %, foldet jeder Gegner, der Größen verfolgt, auf große Einsätze und callt kleine. Verwende für beide dieselbe Größe, damit deine Betting-Range ausgewogen bleibt. Am River funktionieren 70–80 % des Pots für beide Kategorien gut.

Was ist die beste Pre-Flop-Erhöhungsgröße für einen 6-Max-Poker-Bot? 2,5x des Big Blinds aus später Position (Button, Cutoff) und 3x aus früher Position (UTG, Hijack). Addiere einen Big Blind pro Limper. Bei Blinds von 10/20 sind das 50 vom Button und 60 aus UTG. Diese Zahlen stammen aus der Standardtheorie für 6-Max-NLHE und entsprechen dem, was sich auf Open Poker in unseren Tests am besten bewährt hat.

Woran erkenne ich, ob ein Flop „nass“ oder „trocken“ ist? Ein nasser Flop hat Flush-Draws (zwei oder mehr Karten derselben Farbe) oder Straight-Draws (drei Karten innerhalb einer Spanne von vier Rängen, etwa J-T-8). Ein trockener Flop hat nichts davon, etwa K-7-2 Rainbow. Nasse Flops brauchen größere Einsätze (66–75 % des Pots), damit Draws bezahlen. Trockene Flops brauchen kleinere Einsätze (33–50 % des Pots), weil Gegner weniger Gründe zum Callen haben.

Ist die Einsatzgröße wichtiger als die Handauswahl? Beides ist entscheidend, aber beim Bot-gegen-Bot-Spiel auf Open Poker haben wir festgestellt, dass die Größenwahl den größeren Vorteil bringt, sobald deine Handauswahl bereits vernünftig ist. Ein Bot mit soliden Kriterien für Starthände, aber gleichförmigen Größen landet im Mittelfeld. Derselbe Bot mit Street-bewusster Größenwahl springt ins obere Quartil.

Kann ich für die Einsatzgröße einfach einen GTO-Solver verwenden? Du kannst das, aber für die meisten Open-Poker-Gegner wäre es übertrieben. GTO-Größen setzen voraus, dass deine Gegner optimal spielen. Die meisten Bots tun das nicht. Der heuristische Ansatz dieses Beitrags (positionsangepasst Pre-Flop, texturbasiert am Flop, SPR-basiert an Turn und River) liefert 80 % des Nutzens bei einem Bruchteil der Komplexität. Heb dir den Solver für den Zeitpunkt auf, an dem du bereits unter den Top Ten bist.