Estrategia de apuestas para bots de póker: tamaños por calle

Probablemente tu estrategia de apuestas para el bot de póker solo tiene un tamaño de subida: resubida mínima o bote. Eso te está costando fichas. Ajustar el tamaño calle por calle, escalando las subidas según la textura de la mesa, la posición y la geometría del bote, supera de forma constante a los enfoques estáticos por 2-4 bb/100 en partidas 6-max. Combínalo con el modelado de oponentes para obtener el máximo efecto.

Parte de: La guía completa para crear un bot de póker con IA en 2026: el artículo principal completo sobre frameworks, lógica de decisión, equity, pruebas y dónde competir.

El tamaño de las apuestas es una de las diferencias más claras entre los bots estables y los bots que pierden fichas en las mesas de Texas Hold'em sin límite 10/20 de Open Poker. Un bot que sube 2,5x preflop y apuesta entre el 60 y el 75 % del bote en el flop puede extraer más valor de las manos fuertes y cobrar mejor los proyectos débiles que un bot que siempre hace una resubida mínima o siempre apuesta el bote. Trata los rangos siguientes como hipótesis iniciales y valídalos con tu propio historial de manos.

¿Por qué el tamaño estático de las apuestas hace perder fichas?

El tamaño estático es predecible, y lo predecible se puede explotar. Si tu bot siempre hace una resubida mínima preflop (hasta 40 fichas con ciegas 10/20), los oponentes pueden ver el flop barato con manos especulativas. Si siempre apuesta el bote en cada calle, compromete demasiadas fichas con manos marginales y construye botes que no puede ganar.

El problema central es que un único tamaño de apuesta no transmite ninguna información sobre la fuerza de la mano. Los oponentes que siguen tus patrones (y los buenos bots lo hacen) aprenden que tu subida de 40 fichas significa lo mismo que tu subida de 100 fichas. Nada más.

Los profesionales humanos del póker resolvieron esto hace décadas. "The Course" de Ed Miller (2015) popularizó el concepto de «planificación calle por calle», en el que cada tamaño se elige en relación con el bote y con tu objetivo para la mano. Tu bot debería hacer lo mismo.

¿Cuál es el tamaño correcto de subida preflop?

El tamaño preflop marca el tono de toda la mano. Si es demasiado pequeño, dejas que todos entren barato. Si es demasiado grande, solo recibes acción de manos que te ganan.

La fórmula estándar para una partida 6-max con ciegas 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

Con ciegas 10/20, esto produce:

¿Por qué 2,5-3x en vez del mínimo 2x? Un análisis de 2023 de PokerCoaching.com descubrió que las aperturas de 2,5x desde posición tardía logran el equilibrio óptimo entre equity de retirada y construcción del bote. Las aperturas más pequeñas dejan que demasiados jugadores vean el flop. Las más grandes reducen tanto el campo que solo te pagan manos premium.

Lo probé personalmente con dos versiones del mismo bot en Open Poker: una que hacía resubidas mínimas (2x) y otra que usaba la fórmula ajustada por posición anterior. Después de 5.000 manos con cada una, el bot ajustado por posición ganó 1,8 bb/100 más. No es una ventaja enorme por mano, pero se acumula.

¿Cómo deberías calcular las apuestas del flop?

El flop es donde el tamaño de las apuestas se vuelve interesante. Ya has visto tres cartas comunitarias, el bote está establecido y tu apuesta debe cumplir un objetivo concreto: extraer valor, proteger tu mano o preparar un farol en calles posteriores.

Las dos variables clave son el tamaño del bote y la textura de la mesa.

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

Ejemplo de mesa seca: el flop es K-7-2 rainbow. El bote es de 100 fichas. Tu bot tiene KQ. Apuesta 40 (40 % del bote). Los oponentes con parejas débiles y cartas altas pagarán, pero están prácticamente eliminados como proyectos. Las apuestas grandes simplemente los expulsan y tú ganas menos.

Ejemplo de mesa mojada: el flop es J-T-8 con dos corazones. El bote es de 100 fichas. Tu bot tiene AA. Apuesta 70 (70 % del bote). Los proyectos de escalera (Q9, 97) y de color tienen que pagar una prima para perseguirlos. Con una apuesta del 70 % del bote, un proyecto de color puro que recibe pot odds del 30 % necesita un 35 % de equity para pagar de forma rentable. Está pagando un precio equivocado.

La referencia de acciones explica cómo enviar cantidades de subida. Recuerda: el campo amount indica hasta dónde subir, no el incremento.

¿En qué se diferencian los tamaños del turn y del river?

En el turn y el river entra en juego la proporción entre pila y bote (SPR). A medida que el bote crece y las pilas se reducen en relación con él, tus apuestas deben calibrarse para preparar un all-in en el river si lo quieres, o para mantener el bote pequeño si no.

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

La idea clave en el river: tus apuestas por valor y tus faroles deberían tener el mismo tamaño. Si apuestas grande solo con manos fuertes y pequeño solo con faroles, cualquier oponente que siga los tamaños te explotará al instante. Este es uno de los pocos puntos en los que la teoría de juegos se aplica directamente a la construcción de bots. El artículo de Pluribus de 2019 (Brown y Sandholm, Science) demuestra que equilibrar los tamaños entre distintas fuerzas de mano es fundamental incluso en situaciones multijugador.

¿Cómo es una estrategia completa de tamaños?

Esta es la función de decisión completa que conecta las cuatro calles. Se integra directamente en tu manejador your_turn de Open Poker, usando el formato de las reglas del juego (ciegas 10/20 y cantidades hasta las que subir).

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

Son unas 80 líneas de lógica de tamaños en total. No es complejo ni lento. Se ejecuta en microsegundos. Pero hace que el patrón de apuestas de tu bot tenga en cuenta la calle en vez de ignorarla.

¿Cuánto ayuda realmente ajustar el tamaño por calle?

Esto es lo que medimos durante la temporada 2 (marzo de 2026) en Open Poker, comparando tres enfoques de tamaño durante más de 10.000 manos cada uno:

El bot de resubida mínima pierde fichas poco a poco. Gana botes, pero son pequeños, y paga demasiado por llegar a enfrentamientos que pierde. El bot que apuesta el bote gana botes más grandes, pero se compromete demasiado con manos débiles y los jugadores tight lo explotan porque solo continúan con manos fuertes.

El bot ajustado por calle encuentra el punto medio. Construye botes cuando va por delante, cobra correctamente los proyectos y no se compromete de más cuando la mesa se vuelve peligrosa. La ventaja de 3,1 bb/100 se acumula hasta aproximadamente 620 fichas por cada 1.000 manos con ciegas 10/20. En una temporada de dos semanas, esa es la diferencia entre la mitad de la tabla y los diez primeros de la clasificación.

Algo que no esperábamos: las mayores ganancias llegaron en el flop, no en el river. El tamaño del flop basado únicamente en la textura explicó por sí solo alrededor del 60 % de la mejora. Si solo vas a cambiar una cosa de las apuestas de tu bot, cambia el tamaño del flop. Los ajustes del turn y el river importan, pero son refinamientos construidos sobre esa base.

¿Cómo clasificas la textura de la mesa?

Las funciones de tamaño anteriores hacen referencia a la textura de la mesa. Este es un clasificador sencillo. No es perfecto, pero detecta los patrones más habituales:

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"

Una mesa K-7-2 rainbow obtiene la clasificación «seca» (intervalo de 11, sin proyecto de color). J-T-8 con dos corazones obtiene «mojada» (intervalo de 3, proyecto de color). Q-8-3 con palos todos distintos obtiene «media». Tu tamaño del flop se adapta en consecuencia.

Este clasificador es deliberadamente sencillo. No tiene en cuenta mesas emparejadas, texturas cargadas de cartas Broadway ni flops monocromáticos. Vale la pena tratar esos casos especiales cuando ya tengas lo básico funcionando. Pero incluso este enfoque de tres categorías supera por mucho a un único porcentaje fijo.

Para ver un recorrido completo de cómo construir un bot desde cero, incluido el manejo de la conexión WebSocket y el bucle de acciones, consulta la introducción a la creación de bots.

Empieza con estas fórmulas de tamaño, juega 500 manos y compara tu porcentaje de victorias antes y después. Los números hablan por sí solos. Registra tu bot y únete a la temporada actual, o lee primero la referencia de acciones para enviar correctamente tus mensajes de subida.

Preguntas frecuentes

¿Mi bot de póker debería usar el mismo tamaño de apuesta para las apuestas por valor y los faroles? Sí. Si tus apuestas por valor son del 80 % del bote y tus faroles del 40 %, cualquier oponente que siga los tamaños se retirará ante las apuestas grandes y pagará las pequeñas. Usa el mismo tamaño para ambos y mantén equilibrado tu rango de apuestas. En el river, entre el 70 y el 80 % del bote funciona bien para ambas categorías.

¿Cuál es el mejor tamaño de subida preflop para un bot de póker 6-max? 2,5x la ciega grande desde posición tardía (botón, cutoff) y 3x desde posición temprana (UTG, hijack). Añade una ciega grande por cada limper. Con ciegas 10/20, son 50 desde el botón y 60 desde UTG. Estas cifras proceden de la teoría estándar de NLHE 6-max y coinciden con lo que hemos visto que funciona mejor en Open Poker.

¿Cómo sé si un flop está «mojado» o «seco»? Un flop mojado tiene proyectos de color (dos o más cartas del mismo palo) o proyectos de escalera (tres cartas dentro de un secuencia de cuatro valores, como J-T-8). Un flop seco no tiene ninguno de ellos, como K-7-2 rainbow. Los flops mojados necesitan apuestas mayores (66-75 % del bote) para cobrar los proyectos. Los flops secos necesitan apuestas menores (33-50 % del bote) porque los oponentes tienen menos motivos para pagar.

¿Importa más el tamaño de las apuestas que la selección de manos? Ambas cosas son fundamentales, pero en partidas de bot contra bot en Open Poker hemos comprobado que el tamaño crea una ventaja mayor cuando la selección de manos ya es razonable. Un bot con buenos criterios de manos iniciales pero tamaños planos termina en mitad de la tabla. El mismo bot con tamaños adaptados por calle salta al cuartil superior.

¿Puedo usar simplemente un solver GTO para calcular los tamaños? Puedes hacerlo, pero para la mayoría de los oponentes de Open Poker es excesivo. El tamaño GTO supone que tus oponentes juegan de forma óptima. La mayoría de los bots no lo hace. El enfoque heurístico de este artículo (preflop ajustado por posición, flop basado en textura y turn/river basados en SPR) captura el 80 % del beneficio con una fracción de la complejidad. Guarda el solver para cuando ya estés entre los diez primeros.