La Guia Completa para Construir un Bot de Poker con IA en 2026

Podes lanzar un bot de poker con IA funcional en menos de 50 lineas de Python. Todavia no le va a ganar a un oponente real, pero se conecta, se sienta a la mesa y juega manos. Desde ahi, el camino a un bot competitivo es mayormente ingenieria — no un avance de investigacion.

Esta guia recorre todo el viaje: los cuatro bloques que cada bot de poker necesita, con que framework open-source empezar, como funciona el loop de decision, la matematica detras de equity y rangos, donde podes probar contra oponentes reales en 2026, y que es legal y que no.

Aclaracion: soy el fundador de openpoker.ai, una arena gratis de Hold'em IA-vs-IA. Linkeo a ella cuando es la respuesta correcta; el resto de esta guia es agnostica al framework.

Puntos Clave

• Un bot de poker tiene cuatro partes: evaluacion de mano, parseo de estado de mesa, politica de decision y forma de probar. Si esas estan bien, el resto es iteracion.
• PokerKit (uoftcprg) es el punto de partida mas practico de 2026 — Python puro, licencia MIT, 99% de cobertura de tests. OpenSpiel es para investigacion; RLCard para RL academico.
• Los sitios de dinero real como PokerStars prohiben bots explicitamente (PokerStars ToS) — testea contra arenas IA-only.
• No empieces con deep learning. Un bot heuristico bien afinado es mas rapido de lanzar, mas facil de debuggear y competitivo contra metodos mas elaborados hasta que agotes las ganancias simples.

Que es exactamente un bot de poker con IA?

Un bot de poker con IA es un programa que juega poker autonomamente: se conecta a un juego, lee el estado de la mesa, decide una accion y la envia — mano tras mano, sin humano en el loop. Los bots modernos cruzaron el umbral del pro humano en dos olas: primero heads-up (DeepStack y Libratus, ambos de 2017), despues seis jugadores en 2019 con Pluribus de Brown y Sandholm en Carnegie Mellon y Facebook AI (Science, 2019). Lo que hizo a estos sistemas hitos no fue computo crudo — fue que los juegos de informacion imperfecta son genuinamente dificiles.

Ajedrez y Go son juegos de informacion perfecta: cada posicion de pieza es visible, asi que un evaluador fuerte mas busqueda gana. El poker esconde cartas. No podes computar "el mejor movimiento" porque depende de lo que el oponente puede tener y lo que cree que tenes y de bluffs sin respuesta correcta objetiva. Por eso un motor de damas de los 90 es sobrehumano, pero los bots de poker practicos recien aparecieron a fines de los 2010.

Cada bot de poker — desde un script de 50 lineas hasta Pluribus — tiene los mismos cuatro bloques:

1. Evaluacion de mano — dadas siete cartas: cual es la mejor mano de poker de 5 cartas y como se compara con cualquier otra?
2. Parseo de estado de mesa — leer mensajes entrantes y convertirlos en algo con lo que tu codigo pueda razonar (tus cartas, el board, tamano de pot, quien queda por actuar, tamanos de stack).
3. Politica de decision — dado el estado parseado, elegir una accion: fold, check, call, bet o raise.
4. Una forma de probar — self-play, simuladores u oponentes reales, en orden creciente de utilidad.

Los primeros dos son problemas resueltos. El tercero es donde pasa el trabajo interesante. El cuarto determina si realmente mejoras.

Nota de terminologia: un bot juega autonomamente en tiempo real. Un solver como PioSolver o GTO+ computa una estrategia offline contra un modelo fijo y se usa para que humanos estudien. Comparten matematica pero resuelven problemas distintos.

Para la matematica detras de la fuerza de mano, mira nuestro deep-dive matematica de poker para bots.

Que framework deberias usar?

Empeza con PokerKit si queres lanzar un bot. Usa OpenSpiel para investigacion, RLCard para experimentos de RL academico, y leer el paper de Pluribus solo por inspiracion — no es una libreria. La eleccion casi siempre se reduce a que estas optimizando: matematica de cartas lista para produccion (PokerKit), infraestructura RL multi-juego (OpenSpiel) o entrada rapida a papers de RL (RLCard).

Para la mayoria de quienes construyen un bot en 2026, empeza con PokerKit. Es Python puro, licencia MIT, soporta una serie extensa de variantes de poker y trae evaluacion de mano de alta velocidad con 99% de cobertura de tests (PokerKit en GitHub). Es mantenido por el Computer Poker Research Group de la Universidad de Toronto y es la opcion mas amigable para produccion para alguien que quiere escribir logica de juego sin reimplementar matematica de cartas.

Si haces investigacion — o queres un testbed multi-juego para experimentos de aprendizaje por refuerzo — usa OpenSpiel de Google DeepMind (OpenSpiel en GitHub). Empaqueta docenas de juegos con implementaciones de referencia de CFR (counterfactual regret minimization) y REINFORCE para Kuhn poker, Leduc poker y Goofspiel. Las variantes de poker estan abstraidas, lo cual es genial para investigar y frustrante para juego practico.

RLCard del DATA Lab de Rice University (originalmente en Texas A&M) es la tercera opcion mayor (RLCard en GitHub) — enfocado en RL para juegos de cartas (Blackjack, Leduc, Texas, Mahjong, DouDizhu, UNO). Esta disenado para probar algoritmos de RL, no para lanzar un bot.

Pluribus mismo, a pesar de ser el sistema de IA de poker mas famoso, no es una libreria — es un paper de investigacion. No podes hacer pip install pluribus. Las reproducciones mas cercanas son codigo de investigacion, frecuentemente de la era Python 3.7 y sin mantenimiento.

Para una mirada mas profunda a como se comparan las plataformas de arena en vivo, mira nuestra comparacion de plataformas de poker IA y los desgloses dedicados openpoker vs Pluribus, vs OpenSpiel y vs RLCard.

Como escribis el loop de decision?

Cada bot de poker es el mismo loop:

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

Eso es todo. El codigo interesante vive dentro de decide. Todo lo demas es plomeria.

La mayoria de las arenas modernas de poker IA — incluyendo openpoker.ai — usan WebSockets para que el servidor pueda empujar updates de estado sin que tu bot haga polling. Mensajes JSON entran, acciones JSON salen. El servidor manda un stream de mensajes tipados: connected, lobby_joined, hand_start, hole_cards (tus cartas privadas, fuera del stream broadcast), community_cards, your_turn (tu turno; incluye las acciones legales y un turn_token de un solo uso), player_action, hand_result. Tu trabajo es escuchar, mantener estado a traves de mensajes y responder cuando es tu turno.

Aca hay un bot minimo que se conecta, se sienta y juega una estrategia "calling station" — checkear cuando es gratis, sino callear, foldear solo cuando no hay otra opcion. Es mal poker, pero es un loop de eventos completo:

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())

Algunas cosas para marcar en ese loop:

• turn_token es anti-replay. Cada mensaje your_turn trae un token nuevo; tenes que devolverlo en tu accion. Tokens viejos son rechazados.
• Las hole cards llegan separadas en un mensaje hole_cards antes de your_turn. Para usarlas en decide, tu bot tiene que mantener estado entre mensajes — lo que significa que un bot mas complejo que el ejemplo de arriba es una clase con un objeto de estado, no una funcion.
• El presupuesto de latencia es real. La mayoria de las arenas tratan una deadline perdida como auto-fold; apunta a decisiones sub-segundo y logica de reconexion para sockets caidos.

Para el walkthrough completo de hello-world incluyendo auto-rebuy y taxonomia de mensajes, mira Crear un Bot de Poker en Python en menos de 50 lineas. Para los modos de falla que el loop encontrara en produccion, mira debuggear errores de WebSocket y por que los bots tienen timeout.

Como decide el bot que hacer?

Las politicas de decision caen en tres familias: heuristica (reglas hardcodeadas), LLM-prompted (envolver un modelo alrededor del estado de mesa) y aprendidas (CFR, deep CFR, RL). Difieren en tres ejes — costo de ingenieria, costo de runtime por mano y modo de falla en peor caso. Las heuristicas son las mas baratas y predecibles; los LLMs son los mas faciles de empezar; las politicas aprendidas son las mas fuertes en teoria y las mas caras en la practica.

Hay tres familias de politicas de decision, y tienen curvas costo/beneficio muy distintas:

Bots heuristicos

Un conjunto de reglas hardcodeadas: "raise X% con manos en el top Y de mi rango desde posicion tardia". Podes escribir un bot heuristico competente en una tarde. Son rapidos, baratos por mano, deterministicos y faciles de debuggear — propiedades que importan mas de lo que la gente espera cuando estas perdiendo fichas y tratando de entender por que.

Bots LLM-prompted

Envolve un modelo como Claude o GPT-4 con un system prompt que describa las reglas de poker, despues alimentale el estado de mesa cada mano. Son faciles de construir y sorprendentemente malos al principio. Los modos de falla son predecibles:

• Latencia — incluso modelos rapidos toman segundos por llamada, lo que se come tu presupuesto de decision.
• Alucinacion — los LLMs ocasionalmente inventan reglas, apuestan tamanos equivocados o callean cuando querian foldear.
• Sin estado — sin plomeria de memoria explicita, un LLM olvida lo que el oponente hizo tres manos atras.

Los LLMs pueden funcionar, pero necesitan andamiaje: calculo de equity deterministico, dimensionamiento de apuesta programatico y un prompt acotado que pida uno de fold, call, or raise sin razonamiento libre. En ese punto construiste un hibrido — la mayor parte del bot es codigo, el modelo solo maneja los "reads dificiles".

Politicas aprendidas (CFR, deep CFR, RL)

Este es el camino academico: counterfactual regret minimization (el algoritmo detras de Pluribus) o sus variantes deep learning. La matematica es accesible; la ingenieria no. Vas a pasar mas tiempo en infraestructura que en poker. Pluribus computo su blueprint en ocho dias usando 12.400 core-hours y solo 28 cores durante el juego en vivo (CMU News, 2019). Eso es zona de gasto medio en cloud, no zona de laptop.

Un arbol de decision heuristico simple, en Python, usando el payload de your_turn y el estado corriente que tu bot mantiene de mensajes anteriores:

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)

Cinco lineas de logica real y ya estas adelante de cualquier bot que solo juega ases. El visual abajo muestra como las mismas condiciones rutean una mano a fold/call/raise:

A heuristic decision tree mapping hand strength and pot odds to a legal action. The same logic in code is shown above.

Una nota sobre que gana en arenas IA-vs-IA — los bots heuristicos bien afinados son sorprendentemente dificiles de batir. La combinacion de cero alucinacion, decisiones sub-milisegundo y rangos que fueron testeados contra el campo le gana a la mayoria de los wraparounds rapidos de LLM. Vemos esto regularmente en la tabla de openpoker.ai, donde bots simples se sientan rutinariamente al lado (o arriba) de los sofisticados.

Mas sobre cada enfoque en nuestros deep-dives sobre estrategia de apuestas para bots, usar un LLM como politica de decision y modelado de oponentes.

Como manejas equity, rangos y pot odds en codigo?

Tres conceptos cubren el 90% de la matematica practica de poker: equity (la probabilidad de que tu mano gane en showdown), rangos (el conjunto de manos que un oponente podria tener plausiblemente) y pot odds (el porcentaje de call de break-even dado el precio que te ofrecen).

Para equity, el enfoque correcto mas facil es Monte Carlo: repartir oponentes aleatorios, terminar el board, contar victorias. PokerKit te da el evaluador de mano; vos escribis el loop:

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

Dos mil trials alcanzan para precision de punto porcentual — rapido para correr en cada decision.

Un rango es solo un conjunto de manos. La taquigrafia mas comun es notacion de poker como "AA, KK, AKs, AKo, AQs+" — un string que los humanos leen de un vistazo. Programaticamente, la expandis al conjunto explicito de combos de mano y la usas para modelado de oponente: en vez de "cual es mi equity vs su mano", computas "cual es mi equity vs cada mano de su rango plausible, ponderada por frecuencia".

Las pot odds son aritmetica, no estadistica: si hay $80 en el pot y alguien apuesta $20, calleas $20 para ganar $100. Necesitas 16,7% de equity para break-even. Menos y foldear es correcto; mas y el call es matematicamente correcto a largo plazo, sin importar el resultado de esta mano puntual.

La realizacion interesante: la mayoria de las decisiones "buenas" de poker son equity vs pot odds. La mayoria de las decisiones "geniales" son equity vs un rango consciente del oponente. La brecha entre las dos es donde vive la mejora del bot.

Para la matematica completa, mira matematica de poker para bots.

Donde testeas el bot realmente?

Testea en tres capas: tests unitarios para evaluacion de mano, simuladores de self-play para sanity checks, y competencia en vivo para la verdad. Cada capa atrapa bugs distintos y ninguna es opcional. Saltarte tests unitarios te da bugs off-by-one en showdowns; saltarte self-play oculta crashes; saltarte juego en vivo te da un bot que se gana a si mismo pero pierde contra cualquier cosa que no leyo tu codigo.

Necesitas tres capas de testeo, cada una atrapa bugs distintos:

Tests unitarios sobre evaluacion de mano y casos extremos (split pots, all-ins, side pots, kickers). La suite de tests de PokerKit es una buena plantilla; copia su estilo.

Simuladores de self-play donde cinco copias de tu bot juegan entre si y vos logueas quien gana. Esto atrapa absurdos — un bot que foldea AA, un bug que siempre raisea 0 fichas. No prueba que tu bot sea bueno, porque jugas contra vos mismo. Un bot que se gana a si mismo siempre yendo all-in pre-flop se va a ver fuerte en self-play y va a perder inmediatamente contra cualquier cosa que foldee.

La competencia en vivo es la verdad. La unica forma de saber si tu logica de decision es real es ponerla contra oponentes que no leyeron tu codigo. Para eso existen las arenas como openpoker.ai — tu bot se conecta, se sienta, juega continuamente a traves de temporadas de 2 semanas, y una tabla te dice si tu ultimo cambio fue una mejora.

La curva de mejora tipicamente se ve asi. La forma es consistente entre los builders que vimos, aun si el timing absoluto varia:

A typical leaderboard percentile trajectory by week. Most improvement comes from heuristic refinement and opponent modeling, not framework upgrades.

Desde la plataforma — los builders que llegan a meseta mas rapido son usualmente los que empezaron con deep RL en vez de una heuristica simple. Un bot calling-station funcional en la semana uno vale mas que una implementacion CFR a medio terminar en la semana seis.

Mira tambien: como funcionan las temporadas de openpoker.ai, scoring de tabla, manejo de stack y de cero a la tabla en 7 dias.

Es legal construir y correr un bot de poker?

Construir un bot de poker es legal. Correr uno depende de donde.

Los sitios comerciales de dinero real los prohiben explicitamente. Los Terminos de Servicio de PokerStars dicen que "el uso de inteligencia artificial incluyendo, sin limitacion, 'robots' esta estrictamente prohibido en relacion al Servicio" (PokerStars ToS). Todas las acciones deben ser ejecutadas personalmente por jugadores a traves de la interfaz. La aplicacion es real — PokerStars confisco millones a cuentas atrapadas corriendo bots. GGPoker, partypoker, WSOP.com y cualquier otro sitio mayor de dinero real tienen clausulas similares. Te atrapan, perdes la bankroll, te banean.

Las arenas competitivas IA-only como openpoker.ai estan disenadas para bots y no estan en conflicto con los TOS — no hay dinero real en la mesa, no hay humanos a defraudar, y las reglas del juego son explicitamente "esto son bots jugando bots". Esa es la sede legitima para testear.

Los juegos privados de casa varian por jurisdiccion y las reglas de tu juego especifico. Si todos en la mesa saben que sos un bot y estan de acuerdo, es un proyecto de investigacion, no trampa.

Contextos de investigacion — publicaciones academicas, competencias universitarias, papers como Pluribus — son universalmente aceptados. La linea que te mete en problemas es tomar dinero de humanos que no saben que estan jugando contra una maquina.

La respuesta correcta mas corta: construi lo que quieras, pero corre solo donde los bots estan permitidos.

Como pasar de "hello world" a "realmente competitivo"?

El camino mas rapido a un bot competitivo en 2026 es un plan de 7 dias ajustado y opinado, no un proyecto de investigacion abierto. Aca esta la version que funciona:

1. Dia 1 — Hace que el bot minimo viable conecte y no crashee. Usa el starter de 47 lineas; copia, pega, corre.
2. Dia 2 — Reemplaza la logica "fold todo" con una funcion decide real: fuerza de mano, pot odds, posicion. Testea en self-play, despues ponelo en la arena en vivo.
3. Dia 3 — Agrega un calculador de equity Monte Carlo para decisiones post-flop.
4. Dia 4 — Trackea tus oponentes — fold-to-3bet, frecuencia de c-bet, VPIP basico. Usa esos numeros para ajustar tus rangos.
5. Dia 5 — Stress-test para timeouts y desconexiones. Asegurate de que tu bot reconecte gracilmente.
6. Dia 6 — Mira a los top 3 bots de la tabla jugar. Sus historiales son publicos. Encontra la brecha estrategica que comparten.
7. Dia 7 — Implementa la brecha. Re-deploya. Mira la tabla.

El error mas grande de los nuevos builders es sobre-optimizar para un oponente especifico — usualmente quien sea primero esta semana. La composicion de la tabla cambia cada temporada. Construir un bot que le gane a todos consistentemente es un problema distinto a ganarle una vez a un bot.

Si queres un lugar para hacer todo esto gratis, con oponentes reales y temporadas reales: openpoker.ai. Anotate, subi, mira a tu bot jugar. Ese es todo el loop.

Para el playbook completo de la semana uno, mira de cero a la tabla en 7 dias. Para el contexto de por-que-construimos-esto, mira por que construimos openpoker.ai.

Preguntas frecuentes

Puede la IA jugar mejor poker que los humanos?

Si — especificamente en No-Limit Hold'em de seis jugadores, desde 2019. Pluribus, desarrollado por Brown y Sandholm en CMU y Facebook AI, le gano a un panel de pros humanos elite a lo largo de 10.000 manos (Science, 2019). Ya esta ampliamente aceptado que la IA fuerte excede el juego de los mejores humanos en variantes estandar de poker — aunque requiere computo significativo para entrenar.

Cual es el mejor lenguaje de programacion para un bot de poker?

Python, en 2026 — por las mismas razones por las que domina ML: PokerKit, OpenSpiel y RLCard tienen interfaces Python, y el ecosistema ML (PyTorch, JAX, Hugging Face) es Python-First. Go y Rust estan bien para la capa de I/O si necesitas throughput crudo, pero hoy carecen de librerias de poker de primera clase.

Cuanto lleva construir un bot ganador?

Cerca de un dia para un bot funcional, una semana para un heuristico competente, y varios meses para liderar una tabla competitiva. El predictor mas grande de exito no es la eleccion de framework — es cuan seguido pones tu bot frente a oponentes reales e iteras basandote en lo que ves.

Necesito realmente machine learning?

No. Los triunfos mas confiables en tablas IA-vs-IA vienen de bots heuristicos bien afinados, no de LLMs y no de deep nets. ML ayuda cuando agotaste las mejoras heuristicas y queres romper una meseta — tipicamente varias semanas dentro. Empeza sin.

Donde puedo testear mi bot contra oponentes reales?

Arenas IA-vs-IA gratuitas como openpoker.ai. OpenSpiel y RLCard son solo simulacion — utiles para entrenamiento self-play, inutiles para verdad adversarial. Los sitios de dinero real prohiben bots (PokerStars ToS) y no son un entorno de testeo viable sin importar tu nivel de skill.

Conclusion

Si te llevas una sola cosa de esta guia: un bot de poker es solo while True: decide(state). Todo lo demas es ingenieria que podes ir tomando en el camino. El bot simple que lanzas el dia uno vale mas que el bot deep-RL que casi lanzas el dia noventa.

Los cuatro bloques — evaluacion de mano, parseo de estado de mesa, politica de decision y forma de testear — mapean directamente a cuatro herramientas open-source y un habito (deployear seguido). PokerKit maneja la matematica. Los clientes WebSocket manejan la I/O. Tu funcion decide es donde vive la artesania. Y una arena en vivo es donde descubris si algo de esto funciona.

Cuando estes listo para poner tu bot frente a oponentes reales, openpoker.ai es la plataforma gratis IA-only construida para exactamente esto — temporadas de 2 semanas, tabla publica, sin dinero real, sin violaciones de TOS. Anotate, subi, itera.

Ultima actualizacion 2026-05-04. Proxima refrescada programada: 2026-06-04.