Guia completo para criar um bot de pôquer com IA em 2026

Um cliente pequeno em Python já pode conectar seu bot, colocá-lo numa mesa e jogar as primeiras mãos. Isso ainda não o torna competitivo, mas dá uma base concreta para evoluir. A partir daí, boa parte do trabalho é engenharia: organizar o estado, tomar decisões dentro do prazo e medir o efeito de cada mudança.

Este guia acompanha esse percurso. Você vai conhecer os quatro componentes de um bot, comparar ferramentas de código aberto, entender o ciclo de decisão e a matemática da equidade, escolher onde testar e reconhecer os limites de uso de bots em diferentes ambientes.

Sobre o autor: sou o fundador do openpoker.ai, uma arena gratuita de Hold'em em que bots enfrentam outros bots. Indico a plataforma quando ela atende ao caso descrito; as demais explicações não dependem de um framework específico.

Pontos principais

• Todo bot precisa avaliar mãos, interpretar o estado da mesa, escolher ações e ter uma forma de testar. Com essa base funcionando, você pode melhorar uma parte por vez.
• PokerKit (uoftcprg) é um ponto de partida prático: Python puro, licença MIT e ampla cobertura de testes. OpenSpiel atende à pesquisa; RLCard, aos experimentos acadêmicos de aprendizado por reforço.
• Sites com dinheiro real, como PokerStars, proíbem bots em seus termos (termos do PokerStars). Faça seus testes em ambientes que permitam explicitamente jogadores automatizados.
• Comece com regras simples. Um bot heurístico é mais rápido de colocar em funcionamento e mais fácil de depurar. Explore essas melhorias antes de investir em deep learning.

O que é um bot de pôquer com IA?

É um programa que joga de forma autônoma: conecta-se a uma partida, lê o estado da mesa, escolhe uma ação e a envia, mão após mão. A pesquisa em bots superou jogadores profissionais primeiro no heads-up, com DeepStack e Libratus em 2017, e depois no jogo de seis participantes, com o Pluribus de Brown e Sandholm, da Carnegie Mellon e do Facebook AI, em 2019 (Science, 2019). O marco foi lidar com informação incompleta, não apenas realizar mais cálculos.

No xadrez e no Go, todas as peças estão visíveis. São jogos de informação perfeita. No pôquer, parte das cartas fica escondida. A melhor decisão depende das mãos possíveis do adversário, do que ele acredita sobre a sua mão e da possibilidade de blefe. Nem sempre existe uma jogada objetivamente certa para uma situação isolada. Essa diferença explica por que sistemas capazes de superar humanos em outros jogos surgiram antes dos resultados mais fortes no pôquer.

Do script inicial a um sistema de pesquisa como o Pluribus, a estrutura básica tem quatro partes:

1. Avaliação de mãos: entre sete cartas, identificar a melhor combinação de cinco e compará-la com outra mão.
2. Leitura do estado da mesa: transformar as mensagens recebidas em dados úteis, como cartas privadas, cartas comunitárias, pote, jogadores que ainda precisam agir e quantidade de fichas de cada um.
3. Estratégia de decisão: a partir desse estado, escolher entre fold, check, call, bet e raise, respeitando as ações permitidas.
4. Testes: começar com simulações e partidas entre cópias do bot, depois avaliar o comportamento contra outros adversários.

As duas primeiras partes já contam com boas ferramentas. A terceira concentra o trabalho de estratégia. A quarta mostra se uma alteração realmente trouxe alguma melhora.

Uma distinção importante: um bot joga em tempo real. Um solver, como PioSolver ou GTO+, calcula estratégias offline para um modelo definido e serve de ferramenta de estudo. Eles compartilham conceitos matemáticos, mas resolvem problemas diferentes.

Para entender os cálculos usados na avaliação de decisões, leia matemática do pôquer para bots.

Qual framework usar?

Para colocar um bot em funcionamento, comece pelo PokerKit. Para pesquisa, considere OpenSpiel; para experimentos acadêmicos de aprendizado por reforço, RLCard. O Pluribus é uma referência de pesquisa, não uma biblioteca para instalar. A escolha depende do seu objetivo: trabalhar com cartas e mãos, experimentar algoritmos em vários jogos ou reproduzir uma abordagem acadêmica.

O PokerKit atende bem a quem quer escrever a estratégia sem implementar toda a matemática das cartas. É feito em Python, usa licença MIT, oferece várias modalidades de pôquer e inclui avaliação rápida de mãos. O projeto informa uma cobertura de testes próxima de 99% (PokerKit no GitHub). Ele é mantido pelo Computer Poker Research Group da Universidade de Toronto.

Para pesquisa e experimentos de aprendizado por reforço em vários jogos, há o OpenSpiel, do Google DeepMind (OpenSpiel no GitHub). O projeto reúne jogos e implementações de referência de algoritmos como CFR, ou minimização de arrependimento contrafactual, e REINFORCE. Inclui Kuhn poker, Leduc poker e Goofspiel. As versões simplificadas desses jogos facilitam os experimentos, mas exigem adaptação para uma partida completa de Hold'em.

O RLCard, do DATA Lab da Rice University, originalmente ligado à Texas A&M, é outra opção (RLCard no GitHub). Seu foco são experimentos com aprendizado por reforço em jogos de cartas, como Blackjack, Leduc, Texas, Mahjong, DouDizhu e UNO. É uma ferramenta para testar algoritmos, não um cliente pronto para conectar à arena.

Já o Pluribus é um sistema descrito em um trabalho de pesquisa. Não existe uma biblioteca oficial que você possa obter com pip install pluribus. As reproduções disponíveis costumam ser projetos acadêmicos, às vezes ligados a versões antigas do Python e sem manutenção. Para entender o que aproveitar da pesquisa na construção de um bot, leia Pluribus explicado para desenvolvedores.

Para comparar os ambientes de jogo, veja a comparação de plataformas de pôquer com IA e os textos sobre OpenPoker e Pluribus, OpenSpiel e RLCard.

Como escrever o ciclo de decisão?

O funcionamento básico de um bot cabe neste ciclo:

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

A estratégia fica dentro de decide. O restante do programa cuida da conexão, da leitura das mensagens e do envio das ações.

Arenas como o openpoker.ai usam WebSockets para enviar atualizações assim que elas acontecem. O bot não precisa consultar o servidor repetidamente. Entram mensagens JSON e saem ações JSON. Entre os tipos recebidos estão connected, lobby_joined, hand_start, hole_cards, community_cards, your_turn, player_action e hand_result. As cartas privadas chegam apenas ao seu bot; your_turn informa as ações permitidas e o token necessário para responder. Seu trabalho é manter o estado atualizado e agir na hora certa.

Este exemplo conecta o bot à arena e usa a estratégia conhecida como calling station: dá check quando possível, paga nos demais casos e desiste se não houver outra opção. A estratégia é limitada, mas permite observar o ciclo completo de mensagens:

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

Preste atenção a três detalhes:

• turn_token evita a repetição de ações antigas. Devolva na ação o token da mensagem your_turn correspondente. Tokens de outros turnos são rejeitados.
• As cartas privadas chegam separadamente, em hole_cards, antes de your_turn. Para usá-las em decide, guarde o estado entre as mensagens. Conforme o bot cresce, faz sentido separar esse estado em um objeto próprio.
• O prazo de decisão precisa ser respeitado. Uma resposta atrasada pode resultar em fold automático. Procure responder em menos de um segundo nas decisões simples e trate quedas de conexão.

O passo a passo de conexão, incluindo as mensagens e o rebuy automático, está em crie seu primeiro bot em Python. Para lidar com falhas, continue com erros de WebSocket e por que o bot fica sem tempo.

Como o bot decide o que fazer?

As políticas de decisão se dividem em três famílias: heurísticas (regras codificadas manualmente), baseadas em LLM (fornecer o estado da mesa a um modelo de linguagem) e aprendidas (CFR, deep CFR, RL). Elas diferem em três eixos: custo de engenharia, custo de execução por mão e modo de falha no pior caso. Heurísticas são as mais baratas e previsíveis; LLMs são as mais fáceis para começar; políticas aprendidas são, em teoria, as mais fortes e, na prática, as mais caras.

Existem três famílias de políticas de decisão, e as curvas de custo/retorno são muito diferentes entre elas:

Bots heurísticos

Um conjunto de regras codificadas manualmente: "aumentar X% com mãos entre as Y melhores do meu range quando estou em posição final". Você consegue escrever um bot heurístico competente em uma tarde. Eles são rápidos, baratos de executar por mão, determinísticos e fáceis de depurar - características mais importantes do que as pessoas imaginam quando estão perdendo fichas e tentando entender o motivo.

Bots baseados em prompts para LLM

Você configura um modelo como Claude ou GPT-4 com um prompt de sistema que descreve as regras do pôquer e, a cada mão, fornece o estado da mesa. Eles são fáceis de construir e surpreendentemente ruins no início. Os modos de falha são previsíveis:

• Latência - até os modelos rápidos levam segundos por chamada, consumindo seu orçamento de decisão.
• Alucinação - LLMs ocasionalmente inventam regras, fazem apostas de tamanho errado ou pagam quando queriam desistir.
• Ausência de estado - sem uma camada explícita de memória, um LLM esquece o que seu oponente fez três mãos atrás.

LLMs podem funcionar, mas precisam de uma estrutura de suporte: cálculo determinístico de equidade, dimensionamento programático das apostas e um prompt rigorosamente limitado que peça fold, call ou raise, sem explicações fora do formato esperado. Nesse ponto, você construiu um híbrido - a maior parte do bot é código, e o modelo trata apenas dos casos de "leitura difícil".

Políticas aprendidas (CFR, deep CFR, RL)

Este é o caminho acadêmico: minimização de arrependimento contrafactual (o algoritmo por trás do Pluribus) ou suas variantes de deep learning. A matemática é acessível; a engenharia, não. Você gastará mais tempo com infraestrutura do que com pôquer. O Pluribus calculou seu blueprint em oito dias usando 12.400 horas de núcleo e apenas 28 núcleos durante o jogo ao vivo (CMU News, 2019). Esse treinamento exige infraestrutura e orçamento de nuvem, além do que um notebook costuma oferecer.

Uma árvore de decisão heurística simples, em Python, usando o payload your_turn e o estado corrente que seu bot mantém a partir das mensagens 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)

Com cinco linhas de lógica real, você já está à frente de qualquer bot que jogue apenas com ases. O visual abaixo mostra como as mesmas condições encaminham uma mão para desistir/pagar/aumentar:

Uma árvore de decisão heurística que relaciona a força da mão e as pot odds a uma ação legal. A mesma lógica em código aparece acima.

Uma observação sobre o que vence em arenas de IA contra IA - bots heurísticos bem ajustados são surpreendentemente difíceis de vencer. A combinação de alucinação zero, decisões em menos de um milissegundo e ranges que foram efetivamente testados contra o campo supera a maioria dos wrappers rápidos de LLM. Vemos isso regularmente na classificação da openpoker.ai, onde bots simples costumam ficar lado a lado (ou acima) de bots sofisticados.

Para saber mais sobre cada abordagem, veja nossos guias aprofundados sobre estratégia de apostas para bots de pôquer, usar um LLM como política de decisão e modelagem de oponentes.

Como você lida com equidade, ranges e pot odds no código?

Três conceitos cobrem 90% da matemática prática do pôquer: equidade (a probabilidade de sua mão vencer no showdown), ranges (o conjunto de mãos que um oponente poderia plausivelmente ter) e pot odds (a porcentagem de equilíbrio para pagar, dado o preço oferecido).

Para calcular a equidade, a abordagem correta mais fácil é Monte Carlo: sortear cartas para os adversários, completar a mesa e contar as vitórias. O PokerKit fornece o avaliador de mãos; você escreve o 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

Duas mil simulações são suficientes para uma precisão de pontos percentuais - rápidas o bastante para serem executadas a cada decisão.

Um range é simplesmente um conjunto de mãos. A abreviação mais comum é uma notação de pôquer como "AA, KK, AKs, AKo, AQs+" - uma string que humanos leem de relance. No código, você a expande para o conjunto explícito de combinações de mãos e a usa na modelagem do oponente: em vez de perguntar "qual é minha equidade contra a mão dele?", calcule "qual é minha equidade contra cada mão do range plausível dele, ponderada pela frequência".

Pot odds são aritmética, não estatística: se há US$ 80 no pote e alguém aposta US$ 20, você paga US$ 20 para ganhar US$ 100. Você precisa de 16,7% de equidade para atingir o ponto de equilíbrio. Qualquer valor menor torna a desistência correta; qualquer valor maior torna o call matematicamente correto no longo prazo, independentemente do resultado desta mão específica.

A conclusão interessante: a maioria das decisões "boas" no pôquer é equidade contra pot odds. A maioria das decisões "ótimas" é equidade contra um range que leva o oponente em conta. É nesse espaço entre as duas que acontece a evolução do bot.

Para ver toda a matemática, consulte matemática de pôquer para bots.

Onde você testa o bot de fato?

Teste em três camadas: testes unitários para avaliação de mãos, simuladores de self-play para verificações básicas de funcionamento e competição ao vivo para descobrir a verdade. Cada camada encontra bugs diferentes, e nenhuma é opcional. Pular os testes unitários deixa erros de índice nas disputas de showdown; pular o self-play esconde travamentos; pular o jogo ao vivo deixa você com um bot que vence a si mesmo, mas perde para qualquer coisa que não tenha lido seu código.

Você precisa de três camadas de testes, cada uma identificando bugs diferentes:

Testes unitários, para avaliação de mãos e casos extremos (potes divididos, all-ins, side pots, kickers). A suíte de testes do PokerKit é um bom modelo; copie seu estilo.

Simuladores de self-play, nos quais cinco cópias do seu bot se enfrentam e você registra quem vence. Isso detecta absurdos - um bot que desiste com AA, um bug que sempre aumenta em 0 fichas. Isso não prova que seu bot é bom, porque você está jogando contra si mesmo. Um bot que vence a si mesmo indo sempre all-in pré-flop parecerá forte no self-play e perderá imediatamente para qualquer coisa que desista.

A competição ao vivo é a verdade. A única forma de saber se sua lógica de decisão funciona de verdade é colocá-la contra oponentes que não leram seu código. É para isso que existem arenas como a openpoker.ai - seu bot se conecta, ocupa um lugar, joga continuamente ao longo de temporadas de duas semanas, e uma classificação mostra se sua última mudança foi uma melhoria.

A curva de evolução normalmente se parece com isto. O formato é consistente entre os criadores que acompanhamos, mesmo que o tempo exato varie:

Trajetória típica do percentil na classificação por semana. A maior parte da melhoria vem do refinamento das heurísticas e da modelagem dos oponentes, não de atualizações do framework.

Da plataforma - os desenvolvedores que estagnam mais rápido geralmente são os que começam com RL profundo em vez de uma heurística simples. Um bot que funciona e joga como calling station na primeira semana vale mais do que uma implementação de CFR pela metade na sexta semana.

Veja também: como funcionam as temporadas no openpoker.ai, pontuação do ranking, gerenciamento de stack e do zero ao ranking em 7 dias.

É legal criar e executar um bot de pôquer?

Criar um bot de pôquer é legal. Executá-lo é que depende de onde você faz isso.

Sites comerciais com dinheiro real os proíbem explicitamente. Os Termos de Serviço do PokerStars afirmam que “o uso de inteligência artificial, incluindo, entre outros, ‘robôs’, é estritamente proibido em conexão com o Serviço” (Termos do PokerStars). Todas as ações devem ser executadas pessoalmente pelos jogadores, por meio da interface de usuário. A fiscalização é real - o PokerStars já confiscou milhões em valores de contas flagradas usando bots. GGPoker, partypoker, WSOP.com e todos os outros grandes sites de dinheiro real têm cláusulas semelhantes. Se for pego, você perde seu bankroll e é banido.

Arenas competitivas exclusivas para IA, como o openpoker.ai, foram projetadas para bots e não entram em conflito com os Termos de Serviço dos sites: não há dinheiro real na mesa, nenhum humano a ser enganado e as regras do jogo dizem explicitamente que “aqui, bots jogam contra bots”. Esse é o ambiente legítimo para testes.

Partidas privadas entre amigos variam conforme a jurisdição e as regras específicas da sua mesa. Se todos souberem que você está usando um bot e estiverem de acordo, trata-se de um projeto de pesquisa, não de trapaça.

Contextos de pesquisa - publicações acadêmicas, competições universitárias e trabalhos como o Pluribus - são universalmente aceitos. A linha que causa problemas é pegar dinheiro de pessoas que não sabem que estão jogando contra uma máquina.

A resposta curta e correta é: crie o que quiser, mas só execute seu bot onde bots sejam permitidos.

Como sair do “olá, mundo” e chegar a algo realmente competitivo?

O caminho mais rápido para um bot competitivo em 2026 é seguir um plano enxuto e bem definido de 7 dias, e não embarcar em um projeto de pesquisa sem prazo. Esta é a versão que funciona:

1. Dia 1 - Faça o bot mínimo viável se conectar sem travar. Use o bot inicial em Python; copie, cole e execute.
2. Dia 2 - Troque a lógica de “foldar tudo” por uma função decide de verdade: força da mão, pot odds e posição. Teste em partidas contra si mesmo e depois coloque o bot na arena ao vivo.
3. Dia 3 - Adicione um calculador de equidade de Monte Carlo para decisões pós-flop.
4. Dia 4 - Monitore seus adversários: fold para 3-bet, frequência de c-bet e VPIP básico. Use esses números para ajustar seus ranges.
5. Dia 5 - Faça testes de estresse para timeouts e desconexões. Garanta que o bot se reconecte corretamente.
6. Dia 6 - Assista aos três melhores bots do ranking jogarem. O histórico das mãos é público. Encontre a lacuna estratégica que eles têm em comum.
7. Dia 7 - Implemente essa melhoria. Faça um novo deploy. Acompanhe o ranking.

O maior erro dos desenvolvedores iniciantes é otimizar demais para um adversário específico - geralmente quem está em primeiro lugar naquela semana. A composição do ranking muda a cada temporada. Criar um bot que vence todos de forma consistente é um problema diferente de derrotar um único bot uma vez.

Se você quer um lugar para fazer tudo isso de graça, contra adversários reais e em temporadas reais: openpoker.ai. Cadastre-se, faça o upload e assista ao seu bot jogar. Esse é o ciclo completo.

Para o guia completo da primeira semana, veja do zero ao ranking em 7 dias. Para entender por que criamos a plataforma, veja por que criamos o openpoker.ai.

Perguntas frequentes

A IA consegue jogar pôquer melhor do que humanos?

Sim - especificamente no No-Limit Hold’em com seis jogadores, desde 2019. O Pluribus, desenvolvido por Brown e Sandholm na CMU e no Facebook AI, derrotou um grupo de profissionais humanos de elite em 10.000 mãos (Science, 2019). Hoje é amplamente aceito que uma IA forte supera os melhores jogadores humanos nas variantes padrão de pôquer - embora seu treinamento exija um poder computacional considerável.

Qual é a melhor linguagem de programação para um bot de pôquer?

Python, em 2026 - pelos mesmos motivos que fazem dela a linguagem dominante em ML: PokerKit, OpenSpiel e RLCard oferecem interfaces em Python, e o ecossistema de ML (PyTorch, JAX e Hugging Face) prioriza Python. Go e Rust são boas opções para a camada de I/O se você precisar de alto volume de entrada e saída, mas hoje não contam com bibliotecas de pôquer de primeira classe.

Quanto tempo leva para criar um bot de pôquer vencedor?

Cerca de um dia para um bot funcional, uma semana para um bot heurístico competente e vários meses para chegar ao topo de um ranking competitivo. O maior indicador de sucesso não é a escolha do framework - é a frequência com que você coloca o bot diante de adversários reais e itera com base no que observa.

Eu realmente preciso de machine learning?

Não. As vitórias mais confiáveis em rankings de IA contra IA vêm de bots heurísticos bem ajustados, e não de LLMs ou redes profundas. O ML ajuda quando você já esgotou as melhorias heurísticas e quer superar um platô - normalmente depois de várias semanas. Comece sem ele.

Onde posso testar meu bot contra adversários reais?

Em arenas gratuitas de IA contra IA, como o openpoker.ai. OpenSpiel e RLCard servem apenas para simulação - são úteis para treinar em partidas contra si mesmo, mas inúteis para descobrir a verdade em um ambiente adversarial. Sites de dinheiro real proíbem bots (Termos do PokerStars) e não são um ambiente de testes viável, independentemente do seu nível de habilidade.

Conclusão

Se você guardar uma única ideia deste guia, que seja esta: um bot de pôquer é apenas while True: decide(state). Todo o resto é engenharia que você pode aprender ao longo do caminho. O bot simples que você coloca no ar no primeiro dia vale mais do que o bot de RL profundo que você quase consegue lançar no nonagésimo dia.

Os quatro blocos fundamentais - avaliação de mãos, interpretação do estado da mesa, política de decisão e uma forma de testar - correspondem diretamente a quatro ferramentas de código aberto e a um hábito (fazer deploy com frequência). O PokerKit cuida da matemática. Clientes WebSocket cuidam do I/O. A estratégia fica na função decide. E é em uma arena ao vivo que você descobre se tudo isso funciona.

Quando estiver pronto para colocar seu bot diante de adversários reais, o openpoker.ai é a plataforma gratuita e exclusiva para IA criada exatamente para isso - temporadas de 2 semanas, ranking público, sem dinheiro real e sem violação de Termos de Serviço. Cadastre-se, faça o upload e itere.

Tradução e revisão editorial: 8 de setembro de 2026.