Der vollständige Leitfaden zum Bau eines KI-Pokerbots im Jahr 2026

Du kannst einen funktionierenden KI-Pokerbot mit weniger als 50 Python-Zeilen zum Laufen bringen. Einen echten Gegner wird er zunächst noch nicht schlagen, aber er verbindet sich, setzt sich an einen Tisch und spielt Hände. Von dort an ist der Weg zu einem konkurrenzfähigen Bot vor allem eine Frage guter Softwareentwicklung - kein wissenschaftlicher Durchbruch.

Dieser Leitfaden begleitet dich durch den gesamten Weg: die vier Bausteine, die jeder Pokerbot braucht, das Open-Source-Framework, mit dem du am besten startest, die Funktionsweise der Entscheidungsschleife, die Mathematik hinter Equity und Ranges, wo du 2026 tatsächlich gegen echte Gegner testen kannst und was legal ist und was nicht.

Hinweis: Ich bin der Gründer von openpoker.ai, einer kostenlosen Hold'em-Arena für KI gegen KI. Ich verlinke darauf, wo es die passende Lösung ist; der restliche Leitfaden ist unabhängig vom Framework.

Die wichtigsten Punkte

• Ein Pokerbot besteht aus vier Teilen: Handbewertung, Auswertung des Tischzustands, einer Entscheidungsstrategie und einer Möglichkeit zum Testen. Wenn diese Grundlagen stimmen, besteht der Rest aus Iteration.
• PokerKit (uoftcprg) ist 2026 der praxistauglichste Ausgangspunkt - reines Python, MIT-lizenziert und mit 99 % Testabdeckung. OpenSpiel eignet sich für Forschung, RLCard für akademische RL-Experimente.
• Echtgeldseiten wie PokerStars verbieten Bots ausdrücklich (PokerStars ToS) - teste stattdessen in Arenen, in denen ausschließlich KI-Spieler antreten.
• Starte nicht mit Deep Learning. Ein kompakter heuristischer Bot ist schneller fertig, leichter zu debuggen und bleibt gegenüber aufwendigeren Methoden konkurrenzfähig, bis du die einfachen Verbesserungen ausgeschöpft hast.

Was genau ist ein KI-Pokerbot?

Ein KI-Pokerbot ist ein Programm, das autonom Poker spielt: Es verbindet sich mit einem Spiel, liest den Tischzustand, entscheidet sich für eine Aktion und übermittelt sie - Hand für Hand, ohne dass ein Mensch eingreift. Moderne Pokerbots übertrafen menschliche Spitzenspieler in zwei Etappen: zunächst im Heads-up (DeepStack und Libratus, beide 2017), dann 2019 an Tischen mit sechs Spielern mit Pluribus von Brown und Sandholm an der Carnegie Mellon University und bei Facebook AI (Science, 2019). Der Meilenstein dieser Systeme lag nicht in bloßer Rechenleistung, sondern darin, dass Spiele mit unvollständiger Information tatsächlich schwierig sind.

Schach und Go sind Spiele mit vollständiger Information: Die Position jeder Figur ist sichtbar, daher genügt ein guter Bewerter zusammen mit Suche, um zu gewinnen. Beim Poker bleiben Karten verborgen. Du kannst nicht „den besten Zug“ berechnen, weil er davon abhängt, was dein Gegner möglicherweise hält, und davon, was er glaubt, dass du hältst, und von Bluffs, für die es keine objektiv richtige Antwort gibt. Deshalb war eine Dame-Engine aus den 1990er-Jahren übermenschlich stark, während praxistaugliche Pokerbots erst Ende der 2010er-Jahre aufkamen.

Jeder Pokerbot - vom 50-Zeilen-Skript bis zu Pluribus - hat dieselben vier Bausteine:

1. Handbewertung - Welche beste 5-Karten-Pokerhand ergeben sieben Karten, und wie schneidet sie im Vergleich zu jeder anderen ab?
2. Auswertung des Tischzustands - Eingehende Nachrichten lesen und in etwas umwandeln, mit dem dein Code arbeiten kann (deine Hole Cards, das Board, die Potgröße, wer noch an der Reihe ist, die Stackgrößen).
3. Entscheidungsstrategie - Ausgehend vom ausgewerteten Zustand eine Aktion wählen: folden, checken, callen, setzen oder erhöhen.
4. Eine Möglichkeit zum Testen - Eigenpartien, Simulatoren oder echte Gegner, in dieser Reihenfolge nach ihrem praktischen Nutzen.

Die ersten beiden Punkte sind gelöst. Die interessante Arbeit steckt im dritten. Der vierte entscheidet darüber, ob du dich tatsächlich verbesserst.

Hinweis zur Terminologie: Ein Bot spielt in Echtzeit autonom. Ein Solver wie PioSolver oder GTO+ berechnet offline eine Strategie gegen ein festgelegtes Modell und wird von Menschen zum Lernen verwendet. Beide nutzen dieselbe Mathematik, lösen aber unterschiedliche Probleme.

Die Mathematik hinter der Schätzung der Handstärke findest du in unserem Poker-Mathematik-Leitfaden für Bots.

Welches Framework solltest du verwenden?

Starte mit PokerKit, wenn du einen Bot zum Laufen bringen möchtest. Verwende OpenSpiel für Forschung, RLCard für akademische RL-Experimente und lies das Pluribus-Paper nur als Inspiration - es ist keine Bibliothek. Die Wahl hängt fast immer davon ab, worauf du optimierst: produktionsreife Kartenmathematik (PokerKit), RL-Infrastruktur für viele Spiele (OpenSpiel) oder einen schnellen Einstieg in RL-Paper (RLCard).

Für die meisten, die 2026 einen Pokerbot bauen, ist PokerKit der beste Start. Es besteht aus reinem Python, steht unter der MIT-Lizenz, unterstützt eine große Zahl von Pokervarianten und bietet eine schnelle Handbewertung mit 99 % Testabdeckung (PokerKit auf GitHub). Das Framework wird von der Computer Poker Research Group der University of Toronto gepflegt und ist die produktionsfreundlichste Option für alle, die Spiellogik schreiben möchten, ohne die Kartenmathematik neu zu implementieren.

Wenn du forschst oder ein Testbett für Reinforcement-Learning-Experimente mit mehreren Spielen brauchst, verwende OpenSpiel von Google DeepMind (OpenSpiel auf GitHub). Es bündelt Dutzende Spiele und Referenzimplementierungen für CFR (Counterfactual Regret Minimization) und REINFORCE für Kuhn Poker, Leduc Poker und Goofspiel. Die Pokervarianten sind abstrahiert - großartig für Forschung, aber frustrierend für praktisches Spielen.

RLCard vom DATA Lab der Rice University (ursprünglich an der Texas A&M) ist die dritte große Option (RLCard auf GitHub) - mit Fokus auf RL in Kartenspielen (Blackjack, Leduc, Texas, Mahjong, DouDizhu, UNO). Es wurde dafür entwickelt, RL-Algorithmen auszuprobieren, nicht dafür, einen Bot produktionsreif zu machen.

Pluribus selbst ist trotz seines Rufs als bekanntestes KI-Pokersystem keine Bibliothek, sondern ein Forschungspapier. Du kannst nicht pip install pluribus ausführen. Die nächsten Nachbildungen sind Forschungs-Code, oft aus der Python-3.7-Zeit und nicht mehr gepflegt. Wenn du die Forschung aus Entwicklersicht verstehen möchtest, lies Pluribus-Pokerbot erklärt.

Einen ausführlicheren Vergleich der Plattformen für Live-Arenen findest du in unserem Vergleich von KI-Pokerplattformen sowie in den detaillierten Gegenüberstellungen openpoker vs. Pluribus, vs. OpenSpiel und vs. RLCard.

Wie schreibst du die Entscheidungsschleife?

Jeder Pokerbot durchläuft dieselbe Schleife:

while True:
    msg = receive_message()
    if msg["type"] == "your_turn":
        action = decide(state)
        send_action(action, turn_token=msg["turn_token"])

Das ist alles. Die interessante Logik steckt in decide. Der Rest ist Infrastruktur.

Die meisten modernen KI-Pokerarenen - einschließlich openpoker.ai - verwenden WebSockets, damit der Server Zustandsaktualisierungen senden kann, ohne dass dein Bot ständig abfragen muss. JSON-Nachrichten gehen hinein, JSON-Aktionen kommen heraus. Der Server sendet eine Folge von Nachrichten mit festgelegten Typen: connected, lobby_joined, hand_start, hole_cards (deine privaten Karten, die nicht über den Broadcast-Kanal gesendet werden), community_cards, your_turn (dein Zug; enthält die zulässigen Aktionen und ein einmaliges turn_token), player_action, hand_result. Deine Aufgabe besteht darin, zuzuhören, den Zustand über mehrere Nachrichten hinweg zu verfolgen und zu antworten, wenn du an der Reihe bist.

Hier ist ein Minimalbot, der sich verbindet, an einen Tisch setzt und nach einer „Calling-Station“-Strategie spielt - checken, wenn es kostenlos ist, ansonsten callen und nur dann folden, wenn es keine andere Möglichkeit gibt. Das ist schlechtes Poker, aber eine vollständige Ereignisschleife:

import asyncio, json, websockets
 
API_KEY = "your-api-key-here"
WS_URL  = "wss://openpoker.ai/ws"
 
async def play():
    headers = {"Authorization": f"Bearer {API_KEY}"}
    async with websockets.connect(WS_URL, additional_headers=headers) as ws:
        await ws.send(json.dumps({"type": "join_lobby", "buy_in": 2000}))
 
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") != "your_turn":
                continue
 
            valid = {a["action"] for a in msg["valid_actions"]}
            choice = "check" if "check" in valid else ("call" if "call" in valid else "fold")
 
            await ws.send(json.dumps({
                "type": "action",
                "action": choice,
                "turn_token": msg["turn_token"],
            }))
 
asyncio.run(play())

Ein paar Punkte, die du bei dieser Schleife beachten solltest:

• turn_token verhindert Wiederholungen. Jede your_turn-Nachricht enthält ein neues Token, das du in deiner Aktion zurücksenden musst. Veraltete Tokens werden abgelehnt.
• Die Hole Cards kommen separat in einer hole_cards-Nachricht vor your_turn. Damit decide sie verwenden kann, muss dein Bot den Zustand über mehrere Nachrichten hinweg speichern - ein komplexerer Bot als das obige Beispiel ist daher eine Klasse mit einem Zustandsobjekt und keine einzelne Funktion.
• Das Latenzbudget ist real. Die meisten Arenen werten das Verpassen einer Frist als automatischen Fold; ziele auf Entscheidungen innerhalb von weniger als einer Sekunde und auf eine Wiederverbindungslogik für abgebrochene Sockets.

Den vollständigen Hello-World-Ablauf einschließlich automatischem Rebuy und einer Übersicht der Nachrichtentypen findest du unter Deinen ersten Pokerbot in Python bauen. Zu den Fehlerfällen, auf die die Schleife im Produktionseinsatz stößt, siehe WebSocket-Fehler debuggen und Warum Pokerbots wegen Zeitüberschreitung aussteigen.

Wie entscheidet der Bot, was er tun soll?

Entscheidungsstrategien lassen sich in drei Familien einteilen: heuristische Strategien (fest codierte Regeln), LLM-gestützte Strategien (ein Sprachmodell erhält den Tischzustand und schlägt eine Aktion vor) und gelernte Strategien (CFR, Deep CFR, RL). Sie unterscheiden sich entlang dreier Achsen: Entwicklungsaufwand, Laufzeitkosten pro Hand und schlimmster möglicher Fehlerfall. Heuristiken sind am günstigsten und am berechenbarsten; mit LLMs kann man am einfachsten anfangen; gelernte Strategien sind theoretisch am stärksten und in der Praxis am teuersten.

Es gibt drei Familien von Entscheidungsstrategien, und ihre Kosten-Nutzen-Kurven unterscheiden sich stark:

Heuristische Bots

Eine Sammlung fest codierter Regeln: „Erhöhe aus später Position mit Händen aus den besten Y Prozent meiner Range in X Prozent der Fälle.“ Einen brauchbaren heuristischen Bot kann man an einem Nachmittag schreiben. Er läuft schnell, ist pro Hand günstig, deterministisch und leicht zu debuggen - Eigenschaften, die wichtiger sind, als viele denken, wenn man Chips verliert und herausfinden will, warum.

LLM-gestützte Bots

Man versieht ein Modell wie Claude oder GPT-4 mit einem Systemprompt, der die Pokerregeln beschreibt, und übergibt ihm in jeder Hand den Tischzustand. Solche Bots lassen sich leicht bauen und sind anfangs überraschend schlecht. Die Fehlerbilder sind vorhersehbar:

• Latenz - selbst schnelle Modelle brauchen pro Aufruf Sekunden, wodurch dein Entscheidungsbudget schrumpft.
• Halluzinationen - LLMs erfinden gelegentlich Regeln, wählen die falsche Einsatzgröße oder callen, obwohl sie folden sollten.
• Kein Zustandsgedächtnis - ohne eine ausdrücklich programmierte Speicheranbindung vergisst ein LLM, was dein Gegner vor drei Händen getan hat.

LLMs können funktionieren, brauchen aber ein Gerüst: deterministische Equity-Berechnung, programmatische Einsatzgrößen und einen streng begrenzten Prompt, der ohne frei formulierte Begründung nur fold, call oder raise anfordert. Dann hast du einen hybriden Bot gebaut - der größte Teil besteht aus Code, während das Modell nur die Fälle übernimmt, in denen eine schwierige Einschätzung nötig ist.

Gelernte Strategien (CFR, Deep CFR, RL)

Das ist der akademische Weg: Counterfactual Regret Minimization (der Algorithmus hinter Pluribus) oder seine Deep-Learning-Varianten. Die Mathematik ist zugänglich, die Umsetzung nicht. Du wirst mehr Zeit in die Infrastruktur als ins Poker investieren. Pluribus berechnete seinen Blueprint in acht Tagen mit 12.400 Core-Stunden und während des Live-Spiels mit nur 28 Kernen (CMU News, 2019). Das liegt eher in der Größenordnung von Cloud-Ausgaben als im Bereich eines Laptops.

Ein einfacher heuristischer Entscheidungsbaum in Python, der den your_turn-Payload und den laufenden Zustand verwendet, den dein Bot aus früheren Nachrichten verwaltet:

def decide(state):
    """Return one of {fold, check, call, raise}."""
    pot       = state["pot"]
    to_call   = state["to_call"]            # tracked from table_state / your_turn
    stack     = state["my_stack"]
    strength  = hand_strength(state["hole_cards"], state["board"])  # 0..1
    pot_odds  = to_call / (pot + to_call) if to_call else 0.0
    valid     = state["valid_actions"]      # set: {"fold", "check", "call", "raise"}
 
    if strength > 0.85 and "raise" in valid:
        return ("raise", min(pot, stack))   # pot-sized bet, capped by stack
    if strength > 0.55 and to_call <= pot * 0.5 and "call" in valid:
        return ("call", None)
    if "check" in valid:
        return ("check", None)
    return ("call", None) if strength >= pot_odds and "call" in valid else ("fold", None)

Fünf Zeilen echter Logik reichen schon, damit du jedem Bot voraus bist, der nur Asse spielt. Die folgende Grafik zeigt, wie dieselben Bedingungen eine Hand zu fold/call/raise führen:

Ein heuristischer Entscheidungsbaum, der Handstärke und Pot Odds auf eine zulässige Aktion abbildet. Dieselbe Logik ist oben im Code zu sehen.

Ein Hinweis darauf, was in KI-gegen-KI-Arenen gewinnt - Gut abgestimmte heuristische Bots sind überraschend schwer zu schlagen. Die Kombination aus null Halluzinationen, Entscheidungen im Submillisekundenbereich und Ranges, die tatsächlich gegen das Teilnehmerfeld getestet wurden, ist den meisten schnell zusammengeschusterten LLM-Wrappern überlegen. Das sehen wir regelmäßig auf der Rangliste von openpoker.ai, wo einfache Bots routinemäßig neben (oder über) ausgefeilten Bots stehen.

Mehr zu den einzelnen Ansätzen findest du in unseren ausführlichen Artikeln über Poker-Bot-Einsatzstrategien, den Einsatz eines LLM als Entscheidungsstrategie und Gegner-Modellierung.

Wie behandelt man Equity, Ranges und Pot Odds im Code?

Drei Begriffe decken 90 % der praktischen Pokermathematik ab: Equity (die Wahrscheinlichkeit, dass deine Hand beim Showdown gewinnt), Ranges (die Menge an Händen, die ein Gegner plausibel halten könnte) und Pot Odds (das Verhältnis des nötigen Calls zum möglichen Gewinn).

Für die Equity ist Monte Carlo der einfachste korrekte Ansatz: den Gegnern zufällige Karten zuteilen, das Board zu Ende spielen und die Gewinne zählen. PokerKit liefert den Hand-Evaluator; die Schleife schreibst du selbst:

import random
from pokerkit import Card, StandardHighHand
 
def equity(hole, board, n_opponents=1, trials=2000):
    deck = [c for c in StandardHighHand.deck() if c not in hole + board]
    wins = 0
    for _ in range(trials):
        random.shuffle(deck)
        opp = deck[:2 * n_opponents]
        runout = deck[2 * n_opponents : 2 * n_opponents + (5 - len(board))]
        my = StandardHighHand.from_game(hole, board + runout)
        opp_hands = [
            StandardHighHand.from_game(opp[i:i+2], board + runout)
            for i in range(0, 2 * n_opponents, 2)
        ]
        if my > max(opp_hands):
            wins += 1
    return wins / trials

Zweitausend Durchläufe reichen für eine Genauigkeit im Prozentpunktebereich - schnell genug, um sie bei jeder Entscheidung auszuführen.

Eine Range ist einfach eine Menge von Händen. Die gebräuchlichste Kurzschreibweise ist die Pokernotation wie AA, KK, AKs, AKo, AQs+ - eine Zeichenkette, die Menschen auf einen Blick lesen. Im Code erweiterst du sie zur vollständigen Menge der Handkombinationen und verwendest sie für die Gegner-Modellierung: Statt „Wie hoch ist meine Equity gegen seine Hand?“ berechnest du „Wie hoch ist meine Equity gegen jede Hand in seiner plausiblen Range, gewichtet nach ihrer Häufigkeit?“

Pot Odds sind reine Arithmetik, keine Statistik: Liegen 80 $ im Pot und jemand setzt 20 $, callst du 20 $, um 100 $ zu gewinnen. Du brauchst 16,7 % Equity, um den Break-even-Punkt zu erreichen. Bei weniger ist Folden korrekt; bei mehr ist der Call langfristig mathematisch richtig, unabhängig vom Ausgang dieser einzelnen Hand.

Die interessante Erkenntnis: Die meisten „guten“ Pokerentscheidungen sind Equity gegen Pot Odds. Die meisten „großartigen“ Entscheidungen sind Equity gegen eine gegnerbezogene Range. In der Lücke zwischen beiden liegt das Verbesserungspotenzial eines Bots.

Die vollständige Mathematik findest du unter Pokermathematik für Bots.

Wo testet man den Bot tatsächlich?

Teste auf drei Ebenen: Unit-Tests für die Handbewertung, Self-Play-Simulatoren für Plausibilitätsprüfungen und Live-Wettbewerbe für die Wahrheit. Jede Ebene findet andere Fehler, und keine ist optional. Wer Unit-Tests überspringt, bekommt Off-by-one-Fehler beim Showdown; wer Self-Play überspringt, übersieht Abstürze; wer Live-Spiele überspringt, erhält einen Bot, der sich selbst schlägt, aber gegen alles verliert, was deinen Code nicht gelesen hat.

Du brauchst drei Testebenen, von denen jede andere Fehler findet:

Unit-Tests für die Handbewertung und Randfälle (Split Pots, All-ins, Side Pots, Kicker). Die Testsuite von PokerKit ist eine gute Vorlage; übernimm ihren Stil.

Self-Play-Simulatoren, in denen fünf Kopien deines Bots gegeneinander antreten und du protokollierst, wer gewinnt. Das findet Absurditäten - einen Bot, der AA foldet, oder einen Fehler, der immer 0 Chips setzt. Es beweist jedoch nicht, dass dein Bot gut ist, weil du gegen dich selbst spielst. Ein Bot, der sich selbst schlägt, indem er vor dem Flop immer All-in geht, wirkt im Self-Play stark und verliert sofort gegen alles, was foldet.

Live-Wettbewerbe zeigen die Wahrheit. Ob deine Entscheidungslogik wirklich funktioniert, erkennst du nur, wenn du sie gegen Gegner einsetzt, die deinen Code nicht gelesen haben. Dafür gibt es Arenen wie openpoker.ai: Dein Bot verbindet sich, nimmt Platz, spielt über zweiwöchige Saisons kontinuierlich und eine Rangliste zeigt dir, ob deine letzte Änderung eine Verbesserung war.

Die Verbesserungskurve sieht typischerweise so aus. Die Form ist bei den von uns beobachteten Entwicklern ähnlich, auch wenn der genaue Zeitplan variiert:

Eine typische Entwicklung des Ranglisten-Perzentils nach Wochen. Der größte Fortschritt entsteht durch die Verfeinerung von Heuristiken und Gegner-Modellierung, nicht durch Upgrades des Frameworks.

Von der Plattform - Die Entwickler, die am schnellsten stagnieren, sind meist diejenigen, die mit Deep Reinforcement Learning statt mit einer einfachen Heuristik begonnen haben. Ein funktionierender Calling-Station-Bot in der ersten Woche ist wertvoller als eine halb fertige CFR-Implementierung in der sechsten Woche.

Siehe auch: Wie Saisons auf openpoker.ai funktionieren, Wertung der Bestenliste, Verwaltung des Bot-Stacks und In 7 Tagen von null zur Bestenliste.

Ist es legal, einen Poker-Bot zu entwickeln und zu betreiben?

Einen Poker-Bot zu entwickeln ist legal. Beim Betreiben hängt die Antwort davon ab, wo du ihn einsetzt.

Kommerzielle Echtgeldseiten verbieten solche Bots ausdrücklich. In den Nutzungsbedingungen von PokerStars steht: „Die Nutzung künstlicher Intelligenz einschließlich, aber nicht beschränkt auf ,Roboter‘ ist im Zusammenhang mit dem Dienst strengstens verboten“ (PokerStars-Nutzungsbedingungen). Alle Aktionen müssen von Spielern persönlich über die Benutzeroberfläche ausgeführt werden. Die Regeln werden tatsächlich durchgesetzt - PokerStars hat von Konten, auf denen Bots entdeckt wurden, bereits Millionenbeträge eingezogen. GGPoker, partypoker, WSOP.com und alle anderen großen Echtgeldseiten enthalten ähnliche Klauseln. Wer erwischt wird, verliert sein Guthaben und wird gesperrt.

Wettbewerbsplattformen ausschließlich für KI wie openpoker.ai sind für Bots gedacht und stehen nicht im Widerspruch zu den Nutzungsbedingungen solcher Seiten: Es geht um kein Echtgeld, niemanden muss man täuschen, und die Spielregeln sagen ausdrücklich: „Hier spielen Bots gegen Bots.“ Das ist der legitime Ort zum Testen.

Private Pokerrunden unterscheiden sich je nach Rechtsordnung und den Regeln deiner konkreten Runde. Wenn alle am Tisch wissen, dass du einen Bot einsetzt, und damit einverstanden sind, handelt es sich um ein Forschungsprojekt und nicht um Betrug.

Forschungskontexte - akademische Veröffentlichungen, Universitätswettbewerbe und Arbeiten wie Pluribus - sind allgemein anerkannt. Problematisch wird es, wenn du Geld von Menschen nimmst, die nicht wissen, dass sie gegen eine Maschine spielen.

Die kürzeste korrekte Antwort lautet: Entwickle, was du möchtest, aber betreibe deinen Bot nur dort, wo Bots erlaubt sind.

Wie kommt man von „Hello World“ zu einem wirklich konkurrenzfähigen Bot?

Der schnellste Weg zu einem konkurrenzfähigen Bot im Jahr 2026 ist ein klarer, fokussierter 7-Tage-Plan und kein ergebnisoffenes Forschungsprojekt. So funktioniert die Variante:

1. Tag 1 - Bringe den minimal funktionsfähigen Bot dazu, sich zu verbinden und nicht abzustürzen. Verwende den ersten Python-Bot: kopieren, einfügen, ausführen.
2. Tag 2 - Ersetze die Logik „immer folden“ durch eine echte decide-Funktion: Handstärke, Pot Odds und Position. Teste zunächst im Selbstspiel und setze den Bot anschließend in der Live-Arena ein.
3. Tag 3 - Füge für Entscheidungen nach dem Flop einen Monte-Carlo-Rechner für die Gewinnwahrscheinlichkeit hinzu.
4. Tag 4 - Beobachte deine Gegner: Fold-to-3-Bet, C-Bet-Häufigkeit und grundlegendes VPIP. Nutze diese Werte, um deine Ranges anzupassen.
5. Tag 5 - Teste Zeitüberschreitungen und Verbindungsabbrüche unter hoher Belastung. Sorge dafür, dass dein Bot sich sauber wieder verbindet.
6. Tag 6 - Sieh dir die drei führenden Bots der Bestenliste beim Spielen an. Ihre Handverläufe sind öffentlich. Finde die eine strategische Lücke, die sie gemeinsam haben.
7. Tag 7 - Schließe diese Lücke. Spiele eine neue Version ein. Beobachte die Bestenliste.

Der größte Fehler neuer Entwickler besteht darin, den Bot auf einen einzigen Gegner zu optimieren - meistens auf denjenigen, der in dieser Woche an erster Stelle steht. Die Zusammensetzung der Bestenliste ändert sich in jeder Saison. Einen Bot zu entwickeln, der gegen alle dauerhaft gut abschneidet, ist eine andere Aufgabe, als einen Bot einmal zu schlagen.

Wenn du all das kostenlos mit echten Gegnern und echten Saisons ausprobieren möchtest: openpoker.ai. Registrieren, Bot hochladen, beim Spielen zusehen. Das ist der gesamte Ablauf.

Den vollständigen Leitfaden für die erste Woche findest du unter In 7 Tagen von null zur Bestenliste. Den Hintergrund dazu, warum wir diese Plattform entwickelt haben, liest du unter Warum wir openpoker.ai entwickelt haben.

Häufig gestellte Fragen

Kann KI besser Poker spielen als Menschen?

Ja - zumindest beim No-Limit Hold'em mit sechs Spielern ist das seit 2019 der Fall. Pluribus, entwickelt von Brown und Sandholm an der CMU und bei Facebook AI, besiegte eine Gruppe herausragender Profispieler über 10.000 Hände (Science, 2019). Inzwischen gilt weithin als anerkannt, dass leistungsfähige KI menschliches Spitzenspiel in den gängigen Poker-Varianten übertrifft - auch wenn für das Training erhebliche Rechenleistung nötig ist.

Welche Programmiersprache eignet sich am besten für einen Poker-Bot?

2026 ist Python die beste Wahl - aus denselben Gründen, aus denen Python das maschinelle Lernen dominiert: PokerKit, OpenSpiel und RLCard bieten allesamt Python-Schnittstellen, und das ML-Ökosystem (PyTorch, JAX, Hugging Face) ist auf Python ausgerichtet. Go und Rust eignen sich für die I/O-Schicht, wenn du maximalen Durchsatz brauchst, aber derzeit fehlen ihnen erstklassige Poker-Bibliotheken.

Wie lange dauert es, einen erfolgreichen Poker-Bot zu entwickeln?

Etwa einen Tag für einen funktionierenden Bot, eine Woche für einen soliden heuristischen Bot und mehrere Monate, um eine anspruchsvolle Bestenliste anzuführen. Der wichtigste Erfolgsfaktor ist nicht die Wahl des Frameworks, sondern wie oft du deinen Bot gegen echte Gegner antreten lässt und ihn anhand deiner Beobachtungen weiterentwickelst.

Brauche ich wirklich maschinelles Lernen?

Nein. Die zuverlässigsten Erfolge in KI-gegen-KI-Bestenlisten stammen von gut abgestimmten heuristischen Bots, nicht von LLMs und nicht von tiefen neuronalen Netzen. ML hilft, wenn du heuristische Verbesserungen ausgeschöpft hast und ein Plateau überwinden möchtest - typischerweise nach mehreren Wochen. Fang ohne ML an.

Wo kann ich meinen Bot gegen echte Gegner testen?

In kostenlosen KI-gegen-KI-Arenen wie openpoker.ai. OpenSpiel und RLCard sind reine Simulationen - nützlich für Training durch Selbstspiel, aber ungeeignet, um sich gegen echte Gegner zu bewähren. Echtgeldseiten verbieten Bots (PokerStars-Nutzungsbedingungen) und sind unabhängig von deinem Spielniveau keine geeignete Testumgebung.

Fazit

Wenn du nur eine Sache aus diesem Leitfaden mitnimmst, dann diese: Ein Poker-Bot ist im Kern einfach while True: decide(state). Alles andere ist Engineering, das du dir unterwegs aneignen kannst. Der einfache Bot, den du am ersten Tag veröffentlichst, ist wertvoller als der Deep-RL-Bot, den du am neunzigsten Tag beinahe fertigstellst.

Die vier Bausteine - Handbewertung, Auslesen des Tischzustands, Entscheidungslogik und eine Testmöglichkeit - entsprechen direkt vier Open-Source-Werkzeugen und einer Gewohnheit (häufiges Deployment). PokerKit übernimmt die Mathematik. WebSocket-Clients erledigen die Ein- und Ausgabe. In deiner decide-Funktion steckt die eigentliche Arbeit. Und in einer Live-Arena findest du heraus, ob das alles funktioniert.

Wenn du bereit bist, deinen Bot gegen echte Gegner antreten zu lassen, ist openpoker.ai die kostenlose, ausschließlich für KI entwickelte Plattform genau dafür - zweiwöchige Saisons, eine öffentliche Bestenliste, kein Echtgeld und keine Verstöße gegen Nutzungsbedingungen. Registrieren, hochladen, weiterentwickeln.

Übersetzung und redaktionelle Prüfung: 8. September 2026.