La guía completa para crear un bot de póker con IA en 2026

Puedes poner en marcha un bot de póker con IA funcional en menos de 50 líneas de Python. Todavía no vencerá a un oponente real, pero podrá conectarse, sentarse en una mesa y jugar manos. A partir de ahí, el camino hacia un bot competitivo es principalmente ingeniería, no un avance revolucionario en investigación.

Esta guía recorre todo el proceso: los cuatro bloques fundamentales que necesita cualquier bot de póker, con qué framework de código abierto conviene empezar, cómo funciona el bucle de decisiones, las matemáticas detrás de la equity y los rangos, dónde puedes probarlo contra oponentes reales en 2026 y qué está permitido legalmente y qué no.

Aviso: soy el fundador de openpoker.ai, una arena gratuita de Hold'em entre IA. Enlazo a ella cuando es la respuesta adecuada; el resto de esta guía no depende de ningún framework concreto.

Ideas clave

• Un bot de póker tiene cuatro partes: evaluación de manos, análisis del estado de la mesa, una política de decisiones y una forma de hacer pruebas. Si resuelves bien esas partes, el resto es iteración.
• PokerKit (uoftcprg) es el punto de partida más práctico en 2026: Python puro, licencia MIT y un 99 % de cobertura de pruebas. OpenSpiel es para investigación; RLCard, para RL académico.
• Los sitios de dinero real como PokerStars prohíben explícitamente los bots (condiciones de PokerStars); prueba en arenas exclusivas para IA.
• No empieces con aprendizaje profundo. Un bot heurístico sólido se publica antes, es más fácil de depurar y puede competir con métodos más sofisticados hasta que hayas agotado las mejoras sencillas.

¿Qué es exactamente un bot de póker con IA?

Un bot de póker con IA es un programa que juega al póker de forma autónoma: se conecta a una partida, lee el estado de la mesa, decide una acción y la envía, mano tras mano, sin intervención humana. Los bots de póker modernos superaron el nivel profesional humano en dos oleadas: primero en heads-up (DeepStack y Libratus, ambos en 2017) y después con seis jugadores en 2019, con Pluribus, creado por Brown y Sandholm en Carnegie Mellon y Facebook AI (Science, 2019). Lo que convirtió a estos sistemas en hitos no fue la potencia de cálculo bruta, sino que los juegos con información imperfecta son realmente difíciles.

El ajedrez y el Go son juegos de información perfecta: la posición de cada pieza es visible, así que un evaluador potente combinado con búsqueda es suficiente para ganar. El póker oculta las cartas. No puedes calcular «la mejor jugada», porque depende de qué podría tener tu oponente, de lo que él cree que tú podrías tener y de faroles que no tienen una respuesta objetivamente correcta. Por eso un motor de damas de los años noventa ya era sobrehumano, mientras que los bots de póker prácticos no aparecieron hasta finales de la década de 2010.

Todos los bots de póker, desde un script de 50 líneas hasta Pluribus, tienen los mismos cuatro bloques fundamentales:

1. Evaluación de manos: dadas siete cartas, ¿cuál es la mejor mano de póker de cinco cartas y cómo se compara con cualquier otra?
2. Análisis del estado de la mesa: leer los mensajes entrantes y convertirlos en algo que tu código pueda interpretar (tus cartas privadas, la mesa, el tamaño del bote, quién debe actuar y los tamaños de los stacks).
3. Política de decisiones: dado el estado analizado, elegir una acción: retirarse, pasar, pagar, apostar o subir.
4. Una forma de hacer pruebas: partidas entre copias del bot, simuladores u oponentes reales, en orden creciente de utilidad.

Los dos primeros son problemas resueltos. El trabajo interesante está en el tercero. El cuarto determina si realmente mejoras.

Nota sobre la terminología: un bot juega de forma autónoma y en tiempo real. Un solver, como PioSolver o GTO+, calcula una estrategia offline contra un modelo fijo y lo utilizan los humanos para estudiar. Comparten las mismas matemáticas, pero resuelven problemas distintos.

Para conocer las matemáticas detrás de la estimación de la fuerza de una mano, consulta nuestro análisis detallado sobre matemáticas del póker para bots.

¿Qué framework deberías usar?

Empieza con PokerKit si quieres poner un bot en funcionamiento. Usa OpenSpiel para investigar, RLCard para experimentos académicos de RL y lee el artículo de Pluribus solo como inspiración: no es una biblioteca. La elección casi siempre depende de qué quieres optimizar: matemáticas de cartas preparadas para producción (PokerKit), infraestructura de RL para varios juegos (OpenSpiel) o una introducción rápida a los artículos de RL (RLCard).

Para la mayoría de las personas que crean un bot de póker en 2026, lo mejor es empezar con PokerKit. Está escrito en Python puro, tiene licencia MIT, admite un conjunto amplio de variantes de póker e incluye una evaluación de manos rápida con un 99 % de cobertura de pruebas (PokerKit en GitHub). Lo mantiene el Computer Poker Research Group de la Universidad de Toronto y es la opción más adecuada para producción si quieres escribir la lógica del juego sin volver a implementar las matemáticas de las cartas.

Si haces investigación, o quieres un banco de pruebas para experimentos de aprendizaje por refuerzo con varios juegos, usa OpenSpiel de Google DeepMind (OpenSpiel en GitHub). Incluye decenas de juegos con implementaciones de referencia de CFR (minimización del arrepentimiento contrafactual) y REINFORCE para el póker de Kuhn, el póker de Leduc y Goofspiel. Las variantes de póker están abstraídas, algo excelente para investigar y frustrante para jugar de forma práctica.

RLCard, del DATA Lab de la Universidad Rice (originalmente de Texas A&M), es la tercera gran opción (RLCard en GitHub): se centra en el RL aplicado a juegos de cartas (Blackjack, Leduc, Texas, Mahjong, DouDizhu y UNO). Está diseñado para probar algoritmos de RL, no para poner un bot en producción.

Pluribus, a pesar de ser el sistema de IA para póker más famoso, tampoco es una biblioteca: es un artículo de investigación. No puedes hacer pip install pluribus. Las reproducciones más cercanas son código de investigación, a menudo de la época de Python 3.7 y sin mantenimiento. Si quieres la versión de la investigación centrada en quienes construyen bots, lee Pluribus: explicación del bot de póker.

Para profundizar en la comparación entre las plataformas de arenas en vivo, consulta nuestra comparativa de plataformas de póker con IA y los análisis específicos de openpoker frente a Pluribus, frente a OpenSpiel y frente a RLCard.

¿Cómo se escribe el bucle de decisiones?

Todos los bots de póker siguen el mismo bucle:

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 código interesante vive dentro de decide. Todo lo demás es infraestructura.

La mayoría de las arenas modernas de póker con IA, incluida openpoker.ai, usan WebSockets para que el servidor pueda enviar actualizaciones de estado sin que tu bot tenga que consultar continuamente. Entran mensajes JSON y salen acciones JSON. El servidor envía un flujo de mensajes tipados: connected, lobby_joined, hand_start, hole_cards (tus cartas privadas, que se mantienen fuera del flujo de difusión), community_cards, your_turn (tu turno; incluye las acciones legales y un turn_token de un solo uso), player_action y hand_result. Tu tarea es escuchar, mantener el estado entre mensajes y responder cuando sea tu turno.

Este es un bot mínimo que se conecta, se sienta y juega con una estrategia de «calling station»: pasa cuando es gratis, paga en cualquier otro caso y solo se retira cuando no hay otra opción. Es mal póker, pero constituye un bucle 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())

Conviene señalar algunos detalles de ese bucle:

• turn_token evita las repeticiones. Cada mensaje your_turn incluye un token nuevo; debes devolverlo en tu acción. Los tokens obsoletos se rechazan.
• Las cartas privadas llegan por separado en un mensaje hole_cards antes de your_turn. Para usarlas en decide, tu bot debe conservar el estado entre mensajes, lo que significa que un bot más complejo que el ejemplo anterior es una clase con un objeto de estado, no una sola función.
• El presupuesto de latencia es real. La mayoría de las arenas consideran que superar el plazo equivale a retirarse automáticamente; busca decisiones en menos de un segundo y una lógica de reconexión para los sockets que se desconecten.

Para ver el tutorial completo de «hola, mundo», incluida la recompra automática y los tipos de mensajes, consulta Crea tu primer bot de póker en Python. Para conocer los fallos con los que se encontrará el bucle en producción, consulta depuración de errores de WebSocket y por qué los bots agotan el tiempo.

¿Cómo decide el bot qué hacer?

Las políticas de decisión se dividen en tres familias: heurísticas (reglas escritas a mano), guiadas por un LLM (proporcionar el estado de la mesa a un modelo de lenguaje) y aprendidas (CFR, deep CFR, RL). Difieren en tres ejes: el coste de ingeniería, el coste de ejecución por mano y el modo de fallo en el peor caso. Las heurísticas son las más baratas y predecibles; los LLM son los más fáciles para empezar; las políticas aprendidas son, en teoría, las más potentes y, en la práctica, las más caras.

Hay tres familias de políticas de decisión, y sus curvas de coste y beneficio son muy diferentes:

Bots heurísticos

Un conjunto de reglas escritas a mano: «sube X % con las manos del Y superior de mi rango desde posiciones tardías». Puedes escribir un bot heurístico competente en una tarde. Son rápidos, baratos de ejecutar por mano, deterministas y fáciles de depurar; propiedades que importan más de lo que la gente espera cuando está perdiendo fichas e intentando averiguar por qué.

Bots guiados por LLM

Configura un modelo como Claude o GPT-4 con un prompt de sistema que describa las reglas del póker y luego pásale el estado de la mesa en cada mano. Son fáciles de construir y sorprendentemente malos al principio. Sus modos de fallo son previsibles:

• Latencia: incluso los modelos rápidos tardan segundos por llamada, lo que consume tu presupuesto de decisión.
• Alucinaciones: los LLM inventan reglas ocasionalmente, apuestan tamaños incorrectos o hacen call cuando querían foldear.
• Sin estado: sin una gestión explícita de la memoria, un LLM olvida lo que hizo tu oponente hace tres manos.

Los LLM pueden funcionar, pero necesitan una estructura de apoyo: cálculo determinista de la equity, tamaños de apuesta programáticos y un prompt estrictamente limitado que pida fold, call o raise, sin razonamiento de texto libre. A esas alturas has construido un híbrido: la mayor parte del bot es código y el modelo solo se ocupa de los casos de «lectura difícil».

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

Este es el camino académico: la minimización del arrepentimiento contrafactual (el algoritmo detrás de Pluribus) o sus variantes de aprendizaje profundo. Las matemáticas son asequibles; la ingeniería, no. Pasarás más tiempo con la infraestructura que con el póker. Pluribus calculó su estrategia base en ocho días usando 12.400 horas de CPU y solo 28 núcleos durante el juego en vivo (CMU News, 2019). Ese entrenamiento requiere infraestructura y presupuesto en la nube, más allá de lo que suele ofrecer un portátil.

Un árbol de decisión heurístico sencillo, en Python, que usa el payload your_turn y el estado acumulado que tu bot mantiene a partir 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)

Con cinco líneas de lógica real ya estás por delante de cualquier bot que solo juegue ases. La imagen siguiente muestra cómo las mismas condiciones dirigen una mano a foldear, hacer call o subir:

Un árbol de decisión heurístico que relaciona la fuerza de la mano y las pot odds con una acción legal. El mismo razonamiento en código aparece arriba.

Una nota sobre qué gana en las arenas de IA contra IA: los bots heurísticos bien ajustados son sorprendentemente difíciles de vencer. La combinación de cero alucinaciones, decisiones en menos de un milisegundo y rangos que se han probado de verdad contra el resto del campo supera a la mayoría de los integraciones apresuradas de LLM. Lo vemos con frecuencia en la clasificación de openpoker.ai, donde los bots sencillos suelen estar junto a los sofisticados (o incluso por encima de ellos).

Para saber más sobre cada enfoque, consulta nuestros análisis detallados sobre estrategia de apuestas para bots de póker, usar un LLM como política de decisión y modelado del oponente.

¿Cómo gestionas la equity, los rangos y las pot odds en el código?

Tres conceptos cubren el 90 % de las matemáticas prácticas del póker: equity (la probabilidad de que tu mano gane al llegar al showdown), rangos (el conjunto de manos que un oponente podría tener de forma plausible) y pot odds (la equity mínima necesaria para igualar sin perder valor esperado, dado el precio que te ofrecen).

Para calcular la equity, el enfoque correcto más sencillo es Monte Carlo: reparte cartas aleatorias a los oponentes, completa la mesa y cuenta las victorias. PokerKit te proporciona el evaluador de manos; tú escribes el bucle:

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 simulaciones bastan para obtener una precisión de puntos porcentuales, lo bastante rápido como para ejecutarlo en cada decisión.

Un rango no es más que un conjunto de manos. La abreviatura más habitual es la notación de póker, como "AA, KK, AKs, AKo, AQs+", una cadena que los humanos leen de un vistazo. Desde el programa, la expandes al conjunto explícito de combinaciones de manos y la usas para modelar al oponente: en vez de preguntar «¿cuál es mi equity contra su mano?», calculas «¿cuál es mi equity contra cada mano de su rango plausible, ponderada por frecuencia?».

Las pot odds son aritmética, no estadística: si hay 80 $ en el bote y alguien apuesta 20 $, haces call de 20 $ para ganar 100 $. Necesitas un 16,7 % de equity para quedar en el punto de equilibrio. Si tienes menos, foldear es correcto; si tienes más, el call es matemáticamente correcto a largo plazo, independientemente del resultado de esta mano concreta.

La conclusión interesante es que la mayoría de las decisiones de póker «buenas» consisten en equity frente a pot odds. La mayoría de las decisiones «excelentes» consisten en equity frente a un rango que tiene en cuenta al oponente. La mejora del bot se encuentra en la diferencia entre ambas.

Para consultar las matemáticas completas, ve a matemáticas del póker para bots.

¿Dónde pruebas realmente el bot?

Prueba en tres niveles: tests unitarios para la evaluación de manos, simuladores de self-play para comprobaciones de coherencia y competición en vivo para conocer la verdad. Cada nivel detecta errores diferentes y ninguno es opcional. Saltarte los tests unitarios te deja con errores de índices al evaluar el showdown; saltarte el self-play oculta fallos; saltarte el juego en vivo te da un bot que se vence a sí mismo, pero pierde contra rivales distintos de sus propias copias.

Necesitas tres niveles de pruebas, cada uno capaz de detectar errores diferentes:

Tests unitarios, para la evaluación de manos y los casos límite (botes divididos, all-ins, botes secundarios y kickers). La suite de tests de PokerKit es una buena plantilla; copia su estilo.

Simuladores de self-play, donde cinco copias de tu bot se enfrentan y registras quién gana. Esto detecta absurdos: un bot que foldea AA o un error que siempre sube 0 fichas. No demuestra que tu bot sea bueno, porque estás jugando contra ti mismo. Un bot que se vence a sí mismo haciendo all-in preflop siempre parecerá fuerte en self-play y perderá de inmediato contra cualquier cosa que foldee.

La competición en vivo es la verdad. La única forma de saber si tu lógica de decisión funciona de verdad es enfrentarla a oponentes que no han leído tu código. Para eso existen arenas como openpoker.ai: tu bot se conecta, toma asiento y juega de forma continua durante temporadas de dos semanas; una clasificación te indica si tu último cambio supuso una mejora.

La curva de mejora suele tener este aspecto. La forma es constante entre los creadores que hemos observado, aunque el momento exacto varía:

Trayectoria típica del percentil de clasificación por semana. La mayor parte de la mejora proviene de perfeccionar las heurísticas y modelar al oponente, no de actualizar el framework.

Desde la plataforma: quienes crean bots y se estancan más rápido suelen ser los que empezaron con RL profundo en lugar de una heurística sencilla. Un bot que juega como calling station y funciona desde la primera semana vale más que una implementación de CFR a medio terminar en la sexta semana.

Consulta también: cómo funcionan las temporadas en openpoker.ai, puntuación de la clasificación, gestión del stack y de cero a la clasificación en 7 días.

¿Es legal crear y ejecutar un bot de póker?

Crear un bot de póker es legal. Ejecutarlo es donde la respuesta depende de dónde.

Los sitios comerciales con dinero real los prohíben explícitamente. Las condiciones de servicio de PokerStars establecen que «el uso de inteligencia artificial, incluidos, entre otros, los “robots”, está estrictamente prohibido en relación con el Servicio» (condiciones de PokerStars). Todas las acciones deben ser ejecutadas personalmente por los jugadores a través de la interfaz de usuario. La aplicación de esta norma es real: PokerStars ha confiscado millones a cuentas sorprendidas ejecutando bots. GGPoker, partypoker, WSOP.com y todos los demás sitios importantes con dinero real tienen cláusulas similares. Si te descubren, perderás tu bankroll y te expulsarán.

Los entornos competitivos exclusivos para IA, como openpoker.ai, están diseñados para bots y no entran en conflicto con las condiciones de servicio de ningún sitio: no hay dinero real sobre la mesa, ningún humano al que engañar y las reglas del juego establecen explícitamente que «son bots jugando contra bots». Ese es el lugar legítimo para hacer pruebas.

Las partidas privadas entre amigos dependen de la jurisdicción y de las reglas concretas de la partida. Si todos los presentes saben que eres un bot y les parece bien, es un proyecto de investigación, no una trampa.

Los contextos de investigación, como publicaciones académicas, competiciones universitarias y trabajos como Pluribus, gozan de aceptación general. El límite que te puede traer problemas es quitarles dinero a personas que no saben que están jugando contra una máquina.

La respuesta correcta más breve es: crea lo que quieras, pero ejecútalo únicamente donde se permitan bots.

¿Cómo pasas de «hola, mundo» a ser realmente competitivo?

La forma más rápida de crear un bot competitivo en 2026 es seguir un plan de 7 días conciso y con decisiones claras, no embarcarse en un proyecto de investigación sin fin. Esta es la versión que funciona:

1. Día 1: consigue que el bot mínimo viable se conecte y no se bloquee. Usa el bot inicial en Python: copia, pega y ejecuta.
2. Día 2: sustituye la lógica de «retirarse siempre» por una función decide real: fuerza de la mano, pot odds y posición. Pruébala en partidas contra sí mismo y después ponla en el entorno en vivo.
3. Día 3: añade una calculadora de equity de Monte Carlo para las decisiones posteriores al flop.
4. Día 4: sigue a tus oponentes: fold-to-3bet, frecuencia de c-bet y VPIP básico. Usa esos números para ajustar tus rangos.
5. Día 5: somete el bot a pruebas de estrés para detectar timeouts y desconexiones. Asegúrate de que se reconecte correctamente.
6. Día 6: observa jugar a los tres mejores bots de la clasificación. Sus historiales de manos son públicos. Encuentra la única carencia estratégica que comparten.
7. Día 7: implementa esa mejora. Vuelve a desplegarlo. Observa la clasificación.

El mayor error que cometen los creadores principiantes es optimizar en exceso para un oponente concreto, normalmente quien ocupa el primer puesto esa semana. La composición de la clasificación cambia en cada temporada. Crear un bot que venza a todos de forma constante es un problema distinto de vencer una vez a un solo bot.

Si quieres un lugar donde hacer todo esto gratis, contra oponentes reales y en temporadas reales: openpoker.ai. Regístrate, sube tu bot y observa cómo juega. Ese es todo el ciclo.

Para consultar la guía completa de la primera semana, mira de cero a la clasificación en 7 días. Para conocer el contexto de por qué lo creamos, consulta por qué creamos openpoker.ai.

Preguntas frecuentes

¿Puede la IA jugar al póker mejor que los humanos?

Sí, concretamente en No-Limit Hold'em para seis jugadores, desde 2019. Pluribus, desarrollado por Brown y Sandholm en CMU y Facebook AI, derrotó a un grupo de profesionales humanos de élite durante 10.000 manos (Science, 2019). Ahora se acepta ampliamente que una IA potente supera el nivel de los mejores humanos en las variantes estándar del póker, aunque entrenarla requiere una capacidad de cómputo considerable.

¿Cuál es el mejor lenguaje de programación para un bot de póker?

Python, en 2026, por las mismas razones por las que domina el aprendizaje automático: PokerKit, OpenSpiel y RLCard tienen interfaces para Python, y el ecosistema de ML (PyTorch, JAX y Hugging Face) prioriza Python. Go y Rust son buenas opciones para la capa de E/S si necesitas un rendimiento bruto, pero actualmente carecen de bibliotecas de póker de primera categoría.

¿Cuánto se tarda en crear un bot de póker ganador?

Aproximadamente un día para tener un bot funcional, una semana para uno competente basado en heurísticas y varios meses para encabezar una clasificación competitiva. El mayor indicador del éxito no es elegir un framework, sino con qué frecuencia enfrentas tu bot a oponentes reales y haces iteraciones basadas en lo que observas.

¿De verdad necesito aprendizaje automático?

No. Las victorias más fiables en las clasificaciones de IA contra IA proceden de bots heurísticos bien ajustados, no de LLM ni de redes profundas. El ML ayuda cuando ya has agotado las mejoras heurísticas y quieres superar un estancamiento, normalmente después de varias semanas. Empieza sin él.

¿Dónde puedo probar mi bot contra oponentes reales?

En entornos gratuitos de IA contra IA, como openpoker.ai. OpenSpiel y RLCard solo sirven para simulaciones: son útiles para entrenar mediante partidas contra uno mismo, pero inútiles para comprobar la verdad frente a adversarios. Los sitios con dinero real prohíben los bots (condiciones de PokerStars) y no son un entorno de pruebas viable, independientemente de tu nivel.

Conclusión

Si solo te quedas con una idea de esta guía, que sea esta: un bot de póker no es más que while True: decide(state). Todo lo demás es ingeniería que puedes aprender sobre la marcha. El bot sencillo que publicas el primer día vale más que el bot de RL profundo que casi consigues publicar el día noventa.

Los cuatro bloques fundamentales (evaluación de manos, análisis del estado de la mesa, política de decisiones y una forma de probar) se corresponden directamente con cuatro herramientas de código abierto y un hábito (desplegar con frecuencia). PokerKit se encarga de las matemáticas. Los clientes WebSocket se encargan de la E/S. La estrategia está en tu función decide. Y un entorno en vivo es donde descubres si algo de todo esto funciona.

Cuando estés listo para enfrentar tu bot a oponentes reales, openpoker.ai es la plataforma gratuita y exclusiva para IA creada exactamente para eso: temporadas de 2 semanas, clasificación pública, sin dinero real y sin infringir condiciones de servicio. Regístrate, sube tu bot e itera.

Traducción y revisión editorial: 8 de septiembre de 2026.