O Guia Completo para Construir um Bot de Poquer com IA em 2026

Voce consegue lancar um bot de poquer com IA funcional em menos de 50 linhas de Python. Ele ainda nao vai vencer um adversario de verdade, mas conecta, senta na mesa e joga maos. Dali em diante, o caminho ate um bot competitivo e principalmente engenharia — nao um avanco de pesquisa.

Este guia percorre toda a jornada: os quatro blocos que todo bot de poquer precisa, com qual framework open-source comecar, como funciona o loop de decisao, a matematica por tras de equity e ranges, onde voce realmente pode testar contra adversarios reais em 2026, e o que e legal e o que nao e.

Aviso: sou o fundador do openpoker.ai, uma arena gratuita IA-vs-IA de Hold'em. Linko para la quando e a resposta certa; o resto deste guia e independente de framework.

Pontos-chave

• Um bot de poquer tem quatro partes: avaliacao de mao, parsing de estado de mesa, politica de decisao e uma forma de testar. Acertando essas, o resto e iteracao.
• PokerKit (uoftcprg) e o ponto de partida mais pratico de 2026 — Python puro, licenca MIT, 99% de cobertura de testes. OpenSpiel para pesquisa; RLCard para RL academico.
• Sites de dinheiro real como PokerStars proibem bots explicitamente (PokerStars ToS) — teste em arenas IA-only.
• Nao comece com deep learning. Um bot heuristico bem ajustado e mais rapido de entregar, mais facil de debugar e competitivo contra metodos mais elaborados ate voce esgotar os ganhos simples.

O que e exatamente um bot de poquer com IA?

Um bot de poquer com IA e um programa que joga poquer de forma autonoma: ele conecta a um jogo, le o estado da mesa, decide uma acao e a envia — mao apos mao, sem humano no loop. Bots modernos cruzaram o limiar do pro humano em duas ondas: primeiro heads-up (DeepStack e Libratus, ambos de 2017), depois seis jogadores em 2019 com Pluribus de Brown e Sandholm em Carnegie Mellon e Facebook AI (Science, 2019). O que tornou esses sistemas marcos nao foi computacao bruta — foi que jogos de informacao imperfeita sao genuinamente dificeis.

Xadrez e Go sao jogos de informacao perfeita: a posicao de cada peca e visivel, entao um avaliador forte mais busca vence. Poquer esconde cartas. Voce nao consegue calcular "o melhor lance" porque o melhor lance depende do que o adversario pode estar segurando e do que ele acha que voce pode estar segurando e de blefes que nao tem resposta certa objetiva. Por isso uma engine de damas dos anos 90 e sobre-humana, mas bots de poquer praticos so emergiram no final dos anos 2010.

Todo bot de poquer — do script de 50 linhas ao Pluribus — tem os mesmos quatro blocos:

1. Avaliacao de mao — dadas sete cartas, qual e a melhor mao de poquer de 5 cartas e como ela se compara a qualquer outra?
2. Parsing de estado de mesa — ler mensagens recebidas e transforma-las em algo com que seu codigo possa raciocinar (suas hole cards, o board, tamanho do pote, quem ainda precisa agir, tamanhos de stack).
3. Politica de decisao — dado o estado parseado, escolher uma acao: fold, check, call, bet ou raise.
4. Uma forma de testar — self-play, simuladores ou adversarios reais, em ordem crescente de utilidade.

Os dois primeiros sao problemas resolvidos. O terceiro e onde acontece o trabalho interessante. O quarto determina se voce realmente melhora.

Nota de terminologia: um bot joga autonomamente em tempo real. Um solver como PioSolver ou GTO+ calcula uma estrategia offline contra um modelo fixo e e usado por humanos para estudar. Compartilham matematica mas resolvem problemas diferentes.

Para a matematica por tras da estimativa de forca de mao, veja nosso deep-dive matematica de poquer para bots.

Qual framework voce deveria usar?

Comece com PokerKit se quer entregar um bot. Use OpenSpiel para pesquisa, RLCard para experimentos de RL academico, e leia o paper do Pluribus apenas para inspiracao — nao e uma biblioteca. A escolha quase sempre se reduz ao que voce esta otimizando: matematica de cartas pronta para producao (PokerKit), infraestrutura RL multi-jogos (OpenSpiel) ou rampa rapida para papers de RL (RLCard).

Para a maioria das pessoas construindo um bot em 2026, comece com PokerKit. E Python puro, licenca MIT, suporta uma serie extensa de variantes de poquer e entrega avaliacao de mao de alta velocidade com 99% de cobertura de testes (PokerKit no GitHub). E mantido pelo Computer Poker Research Group da Universidade de Toronto e e a opcao mais amigavel a producao para alguem que quer escrever logica de jogo sem reimplementar matematica de cartas.

Se voce esta fazendo pesquisa — ou quer um banco de testes multi-jogos para experimentos de aprendizado por reforco — use OpenSpiel do Google DeepMind (OpenSpiel no GitHub). Ele empacota dezenas de jogos com implementacoes de referencia de CFR (counterfactual regret minimization) e REINFORCE para Kuhn poker, Leduc poker e Goofspiel. As variantes de poquer sao abstraidas, o que e otimo para pesquisa e frustrante para jogo pratico.

RLCard do DATA Lab da Rice University (originalmente em Texas A&M) e a terceira opcao principal (RLCard no GitHub) — focado em RL para jogos de cartas (Blackjack, Leduc, Texas, Mahjong, DouDizhu, UNO). E projetado para experimentar algoritmos de RL, nao para entregar um bot.

O Pluribus em si, apesar de ser o sistema de IA de poquer mais famoso, nao e uma biblioteca — e um paper de pesquisa. Voce nao pode rodar pip install pluribus. As reproducoes mais proximas sao codigo de pesquisa, frequentemente da era Python 3.7 e sem manutencao.

Para um olhar mais profundo sobre como as plataformas de arena ao vivo se comparam, veja nossa comparacao de plataformas de poquer com IA e os recortes dedicados openpoker vs Pluribus, vs OpenSpiel e vs RLCard.

Como voce escreve o loop de decisao?

Todo bot de poquer e o mesmo loop:

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

E so isso. O codigo interessante mora dentro de decide. Todo o resto e encanamento.

A maioria das arenas modernas de poquer com IA — incluindo openpoker.ai — usa WebSockets para que o servidor possa empurrar atualizacoes de estado sem que seu bot fique fazendo polling. Mensagens JSON entram, acoes JSON saem. O servidor envia um stream de mensagens tipadas: connected, lobby_joined, hand_start, hole_cards (suas cartas privadas, fora do stream broadcast), community_cards, your_turn (sua vez; inclui as acoes legais e um turn_token de uso unico), player_action, hand_result. Seu trabalho e ouvir, manter estado entre mensagens e responder quando for sua vez.

Aqui esta um bot minimo que conecta, senta e joga uma estrategia "calling station" — checar quando e gratis, callar caso contrario, foldar somente quando nao ha outra opcao. E poquer ruim, mas e um 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())

Algumas coisas para sinalizar nesse loop:

• turn_token e anti-replay. Toda mensagem your_turn traz um token novo; voce precisa devolve-lo na sua acao. Tokens antigos sao rejeitados.
• Hole cards chegam separadas em uma mensagem hole_cards antes de your_turn. Para usa-las em decide, seu bot precisa manter estado entre mensagens — o que significa que um bot mais complexo do que o exemplo acima e uma classe com um objeto de estado, nao uma funcao unica.
• Orcamento de latencia e real. A maioria das arenas trata um deadline perdido como auto-fold; mire em decisoes sub-segundo e logica de reconexao para sockets caidos.

Para o walkthrough completo de hello-world incluindo auto-rebuy e taxonomia de mensagens, veja Construa um Bot de Poquer em Python em menos de 50 Linhas. Para os modos de falha que o loop encontrara em producao, veja debugar erros de WebSocket e por que bots dao timeout.

Como o bot decide o que fazer?

Politicas de decisao se enquadram em tres familias: heuristica (regras codificadas a mao), LLM-prompted (envolver um modelo em torno do estado de mesa) e aprendida (CFR, deep CFR, RL). Diferem em tres eixos — custo de engenharia, custo de runtime por mao e modo de falha no pior caso. Heuristicas sao as mais baratas e previsiveis; LLMs sao as mais faceis de comecar; politicas aprendidas sao as mais fortes em teoria e as mais caras na pratica.

Existem tres familias de politicas de decisao, e elas tem curvas custo/beneficio bem diferentes:

Bots heuristicos

Um conjunto de regras codificadas a mao: "subir X% com maos no topo Y do meu range em posicao tardia". Voce consegue escrever um bot heuristico competente em uma tarde. Sao rapidos, baratos por mao, deterministicos e faceis de debugar — propriedades que importam mais do que as pessoas esperam quando voce esta perdendo fichas e tentando entender por que.

Bots LLM-prompted

Envolva um modelo como Claude ou GPT-4 com um system prompt descrevendo as regras do poquer, depois alimente-o com o estado da mesa a cada mao. Sao faceis de construir e surpreendentemente ruins no inicio. Os modos de falha sao previsiveis:

• Latencia — ate modelos rapidos levam segundos por chamada, o que come seu orcamento de decisao.
• Alucinacao — LLMs ocasionalmente inventam regras, apostam tamanhos errados ou callam quando queriam foldar.
• Sem estado — sem encanamento de memoria explicito, um LLM esquece o que seu adversario fez tres maos atras.

LLMs podem funcionar, mas precisam de andaime: calculo de equity deterministico, dimensionamento de aposta programatico e um prompt apertado que pede um de fold, call, or raise sem raciocinio livre. Nesse ponto voce construiu um hibrido — a maior parte do bot e codigo, com o modelo apenas lidando com os casos de "leitura dificil".

Politicas aprendidas (CFR, deep CFR, RL)

Esse e o caminho academico: counterfactual regret minimization (o algoritmo por tras do Pluribus) ou suas variantes deep learning. A matematica e acessivel; a engenharia nao. Voce vai gastar mais tempo em infraestrutura do que em poquer. O Pluribus calculou seu blueprint em oito dias usando 12.400 core-horas e apenas 28 cores durante o jogo ao vivo (CMU News, 2019). E territorio de gasto medio em cloud, nao territorio de laptop.

Uma arvore de decisao heuristica simples, em Python, usando o payload your_turn e o estado corrente que seu bot mantem de 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)

Cinco linhas de logica real e voce ja esta a frente de qualquer bot que so joga ases. O visual abaixo mostra como as mesmas condicoes roteiam uma mao para 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.

Uma nota sobre o que ganha em arenas IA-vs-IA — bots heuristicos bem ajustados sao surpreendentemente dificeis de bater. A combinacao de zero alucinacao, decisoes sub-milissegundo e ranges que foram realmente testados contra o campo bate a maioria dos wraparounds rapidos de LLM. Vemos isso regularmente no leaderboard do openpoker.ai, onde bots simples rotineiramente sentam ao lado (ou acima) dos sofisticados.

Mais sobre cada abordagem nos nossos deep-dives sobre estrategia de aposta para bot de poquer, usar um LLM como politica de decisao e modelagem de adversario.

Como lidar com equity, ranges e pot odds no codigo?

Tres conceitos cobrem 90% da matematica pratica de poquer: equity (a probabilidade da sua mao vencer no showdown), ranges (o conjunto de maos que um adversario poderia plausivelmente ter) e pot odds (a porcentagem de call de break-even dado o preco oferecido).

Para equity, a abordagem correta mais facil e Monte Carlo: distribua adversarios aleatorios, complete o board, conte vitorias. PokerKit te da o avaliador de mao; voce 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

Dois mil trials sao suficientes para precisao de ponto percentual — rapido o suficiente para rodar em cada decisao.

Um range e apenas um conjunto de maos. A forma mais comum e a notacao de poquer como "AA, KK, AKs, AKo, AQs+" — uma string que humanos leem rapido. Programaticamente, voce a expande para o conjunto explicito de combos e a usa para modelagem de adversario: em vez de "qual minha equity vs a mao dele", calcule "qual minha equity vs cada mao do range plausivel dele, ponderada por frequencia".

Pot odds sao aritmetica, nao estatistica: se ha $80 no pote e alguem aposta $20, voce calla $20 para ganhar $100. Voce precisa de 16,7% de equity para empatar. Menos e foldar e correto; mais e o call e matematicamente certo no longo prazo, independente do resultado dessa mao especifica.

A realizacao interessante: a maioria das decisoes "boas" de poquer e equity vs pot odds. A maioria das decisoes "otimas" e equity vs um range ciente do adversario. A lacuna entre as duas e onde a melhoria do bot vive.

Para a matematica completa, veja matematica de poquer para bots.

Onde voce realmente testa o bot?

Teste em tres camadas: testes unitarios para avaliacao de mao, simuladores de self-play para sanity checks e competicao ao vivo para a verdade. Cada camada pega bugs diferentes e nenhuma e opcional. Pular testes unitarios te da bugs off-by-one no showdown; pular self-play esconde crashes; pular jogo ao vivo te da um bot que ganha de si mesmo mas perde para qualquer coisa que nao leu seu codigo.

Voce precisa de tres camadas de teste, cada uma pegando bugs diferentes:

Testes unitarios sobre avaliacao de mao e casos extremos (split pots, all-ins, side pots, kickers). A suite de testes do PokerKit e um bom modelo; copie o estilo dela.

Simuladores de self-play onde cinco copias do seu bot se enfrentam e voce loga quem ganha. Isso pega absurdos — um bot que folda AA, um bug que sempre sobe 0 fichas. Nao prova que seu bot e bom, porque voce esta jogando contra si mesmo. Um bot que ganha de si mesmo sempre indo all-in pre-flop vai parecer forte em self-play e perder imediatamente para qualquer coisa que folde.

Competicao ao vivo e a verdade. A unica forma de saber se sua logica de decisao e real e coloca-la contra adversarios que nao leram seu codigo. E para isso que existem arenas como openpoker.ai — seu bot conecta, senta, joga continuamente em temporadas de 2 semanas, e um leaderboard te diz se sua ultima mudanca foi uma melhoria.

A curva de melhoria normalmente se parece com isto. O formato e consistente entre os builders que observamos, mesmo se o timing absoluto varia:

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

Da plataforma — os builders que entram em plato mais rapido geralmente sao os que comecaram com deep RL em vez de uma heuristica simples. Um bot calling-station funcional na semana um vale mais que uma implementacao CFR pela metade na semana seis.

Veja tambem: como funcionam as temporadas no openpoker.ai, scoring de leaderboard, gerenciamento de stack e do zero ao leaderboard em 7 dias.

E legal construir e rodar um bot de poquer?

Construir um bot de poquer e legal. Rodar um, a resposta depende de onde.

Sites comerciais de dinheiro real os proibem explicitamente. Os Termos de Servico do PokerStars dizem que "o uso de inteligencia artificial incluindo, sem limitacao, 'robos' e estritamente proibido em conexao com o Servico" (PokerStars ToS). Todas as acoes devem ser executadas pessoalmente por jogadores via interface. A aplicacao e real — PokerStars confiscou milhoes de contas pegas rodando bots. GGPoker, partypoker, WSOP.com e todo outro site grande de dinheiro real tem clausulas similares. Ser pego, perder a bankroll, ser banido.

Arenas competitivas IA-only como openpoker.ai sao projetadas para bots e nao existem em conflito com TOS de site — sem dinheiro real na mesa, sem humanos para enganar, e as regras do jogo sao explicitamente "isto sao bots jogando contra bots". E a sede legitima para testar.

Jogos privados em casa variam por jurisdicao e pelas regras do seu jogo especifico. Se todos a mesa sabem que voce e um bot e estao de acordo, e um projeto de pesquisa, nao trapaca.

Contextos de pesquisa — publicacoes academicas, competicoes universitarias, papers como Pluribus — sao universalmente aceitos. A linha que te coloca em apuros e tirar dinheiro de humanos que nao sabem que estao jogando contra uma maquina.

A resposta correta mais curta: construa o que quiser, mas rode somente onde bots sao permitidos.

Como sair do "hello world" e chegar em "realmente competitivo"?

O caminho mais rapido para um bot competitivo em 2026 e um plano apertado e opinativo de 7 dias, nao um projeto de pesquisa aberto. Aqui esta a versao que funciona:

1. Dia 1 — Faca o bot minimo viavel conectar e nao crashear. Use o starter de 47 linhas; copia, cola, roda.
2. Dia 2 — Substitua a logica "fold em tudo" por uma funcao decide real: forca de mao, pot odds, posicao. Teste em self-play, depois coloque na arena ao vivo.
3. Dia 3 — Adicione um calculador de equity Monte Carlo para decisoes pos-flop.
4. Dia 4 — Acompanhe seus adversarios — fold-to-3bet, frequencia de c-bet, VPIP basico. Use esses numeros para ajustar seus ranges.
5. Dia 5 — Faca stress-test para timeouts e desconexoes. Garanta que seu bot reconecta direito.
6. Dia 6 — Assista os tres melhores bots do leaderboard jogarem. Os historicos de mao sao publicos. Ache a unica lacuna estrategica que eles compartilham.
7. Dia 7 — Implemente a lacuna. Re-deploy. Olhe o leaderboard.

O maior erro de novos builders e super-otimizar para um adversario especifico — geralmente quem estiver em primeiro essa semana. A composicao do leaderboard muda toda temporada. Construir um bot que bate todo mundo consistentemente e um problema diferente de bater um bot uma vez.

Se voce quer um lugar para fazer tudo isso de graca, com adversarios reais e temporadas reais: openpoker.ai. Inscreva-se, faca upload, assista seu bot jogar. Esse e o loop inteiro.

Para o playbook completo da semana um, veja do zero ao leaderboard em 7 dias. Para o contexto por-que-construimos-isso, veja por que construimos o openpoker.ai.

Perguntas frequentes

A IA pode jogar poquer melhor que humanos?

Sim — especificamente em No-Limit Hold'em de seis jogadores, desde 2019. Pluribus, desenvolvido por Brown e Sandholm na CMU e Facebook AI, bateu um painel de pros humanos elite em 10.000 maos (Science, 2019). Hoje e amplamente aceito que IA forte excede o jogo dos melhores humanos em variantes padrao de poquer — embora exija computacao significativa para treinar.

Qual a melhor linguagem de programacao para um bot de poquer?

Python, em 2026 — pelas mesmas razoes que ele domina ML: PokerKit, OpenSpiel e RLCard tem todos interfaces Python, e o ecossistema ML (PyTorch, JAX, Hugging Face) e Python-first. Go e Rust funcionam para a camada de I/O se voce precisa de throughput bruto, mas hoje carecem de bibliotecas de poquer de primeira classe.

Quanto tempo leva para construir um bot vencedor?

Cerca de um dia para um bot funcional, uma semana para um bot heuristico competente, e varios meses para liderar um leaderboard competitivo. O maior preditor de sucesso nao e a escolha de framework — e quao frequentemente voce poe seu bot diante de adversarios reais e itera com base no que ve.

Eu realmente preciso de machine learning?

Nao. As vitorias mais confiaveis em leaderboards IA-vs-IA vem de bots heuristicos bem ajustados, nao de LLMs e nao de deep nets. ML ajuda quando voce esgotou as melhorias heuristicas e quer empurrar alem de um plato — tipicamente varias semanas dentro. Comece sem.

Onde posso testar meu bot contra adversarios reais?

Arenas IA-vs-IA gratuitas como openpoker.ai. OpenSpiel e RLCard sao apenas simulacao — uteis para treino de self-play, inuteis para verdade adversarial. Sites de dinheiro real proibem bots (PokerStars ToS) e nao sao um ambiente de teste viavel independente do seu nivel de skill.

Conclusao

Se voce levar uma coisa deste guia: um bot de poquer e so while True: decide(state). Todo o resto e engenharia que voce vai pegando no caminho. O bot simples que voce entrega no dia um vale mais que o bot deep-RL que voce quase entregou no dia noventa.

Os quatro blocos — avaliacao de mao, parsing de estado de mesa, politica de decisao e forma de testar — mapeiam diretamente para quatro ferramentas open-source e um habito (deployar com frequencia). PokerKit cuida da matematica. Clientes WebSocket cuidam do I/O. Sua funcao decide e onde mora o oficio. E uma arena ao vivo e onde voce descobre se algo disso funciona.

Quando estiver pronto para colocar seu bot diante de adversarios reais, openpoker.ai e a plataforma gratuita IA-only construida exatamente para isso — temporadas de 2 semanas, leaderboard publico, sem dinheiro real, sem violacoes de TOS. Inscreva-se, faca upload, itere.

Ultima atualizacao 2026-05-04. Proximo refresh agendado: 2026-06-04.