QUANTARMY

Vender volatilidad no es dinero gratis: las 3 cifras clave

Jesus Cuesta — Thu, 16 Jul 2026 23:19:23 GMT

El martes que la vol no revirtió

Es un martes por la mañana. Abres el terminal, miras ese valor que llevas semanas siguiendo y su volatilidad implícita a 30 días imprime 48, pegada al techo de su rango anual.

La vol revierte a la media. Lo sabe todo el mundo. Así que haces lo obvio: vendes el straddle. Quizá, si eres prudente, un iron condor.

Dos días después la implícita imprime 61. Tu corto está muy por debajo del agua y la reversión que te habían prometido no aparece por ninguna parte. La posición acaba volviendo —casi entera— tras una semana en la que duermes mal.

¿Qué salió mal? En realidad, nada. Acertaste en que la vol revierte. Pero estabas mirando los árboles sin ver el bosque: un único número de volatilidad implícita, por sí solo, no te dice casi nada sobre si debes venderla, comprarla o dejarla tranquila.

Para operar la reversión de verdad necesitas tres cosas que no se pueden leer en ese único print. Conseguir las tres es lo que separa cobrar prima de donarla. Este artículo es una investigación completa de esas tres cifras — IV/HV Premium, IV Rank y Vol-of-Vol — con las fórmulas, los números del estudio original de Quant Galore × Alphanume Research, una validación independiente con datos reales del VIX y el código para reproducirlo todo.

La reversión existe, pero no es gratis

La reversión a la media de la volatilidad es una de las regularidades más fiables de todos los mercados: la vol salta con el miedo y sangra de vuelta cuando el miedo se desvanece. Es tan fiable que todo el complejo short-vol — cada vendedor de iron condors, cada overwriter de FinTwit — es, en el fondo, la misma apuesta: la vol elevada de hoy estará más baja mañana.

Matemáticamente, la intuición se ancla bien en un proceso de Ornstein-Uhlenbeck. Si la volatilidad $\sigma_t$ siguiera uno:

d\sigma_t = \kappa\,(\theta - \sigma_t)\,dt + \xi\,dW_t

donde $\theta$ es el nivel de largo plazo, $\kappa$ la velocidad de reversión y $\xi$ la volatilidad de la propia volatilidad (guárdate ese $\xi$ , volverá). La vida media de un shock — cuánto tarda en disiparse la mitad — es:

t_{1/2} = \frac{\ln 2}{\kappa}

Y ahí está el primer problema: el modelo que justifica tu operación tiene dos parámetros que no estás mirando. Un $\kappa$ alto te devuelve la vol en días; un $\kappa$ bajo te deja semanas nadando contra corriente. Y un $\xi$ alto convierte la espera en una pelea de cuchillos. "La vol revierte" sin $\kappa$ ni $\xi$ es una frase, no una operación.

El segundo problema es de referencia. El instinto dice: ve vol alta, véndela; ve vol baja, cómprala; cobra la diferencia. Pero ¿alta respecto a qué? Un 48% para una utility regional somnolienta es un incendio de cinco alarmas. Para una biotech pequeña a las puertas de un readout de datos, es barato. El número no significa nada hasta que lo anclas a algo, y "tengo la sensación de que está elevada" no es el ancla que usan los profesionales.

La pregunta correcta se divide en tres:

¿Es cara de verdad? ¿Te están pagando por venderla, en relación con lo que la acción realmente se mueve?
¿Es cara para este nombre? ¿Está estirada dentro de su propio rango histórico, o es simplemente normal-para-ella?
¿Cómo de estable es la propia vol? ¿La reversión volverá como una deriva suave o como una pelea de cuchillos?

Tres preguntas, tres números. Vamos una por una.

¿Cara respecto a qué? La prima de riesgo de volatilidad

La primera acepción de "vol cara" es cara respecto a lo realizado. Es la clásica volatility risk premium (VRP): la brecha entre lo que las opciones están precificando (vol implícita) y lo que la acción realmente entrega (vol realizada).

La vol realizada se estima del histórico de precios. El estimador más simple es el close-to-close:

\hat{\sigma}_{CC} = \sqrt{\frac{252}{N}\sum_{t=1}^{N} r_t^2}, \qquad r_t = \ln\frac{S_t}{S_{t-1}}

y una versión más eficiente estadísticamente es el estimador de Parkinson, que usa el rango máximo-mínimo de cada sesión:

\hat{\sigma}_{P} = \sqrt{\frac{252}{N}\sum_{t=1}^{N}\frac{1}{4\ln 2}\left(\ln\frac{H_t}{L_t}\right)^2}

Con ambas en la mano, la VRP se expresa como spread $s_t = IV_t - HV_t$ o, más limpio y comparable entre nombres, como ratio:

\rho_t = \frac{IV_{30,t}}{HV_{30,t}}

Cuando la implícita a 30 días supera a la realizada a 30 días, $\rho > 1$ y te están pagando más en prima de lo que la acción se ha estado moviendo. Ese es el quid del feed IV/HV Premium: por nombre y por día, implícita contra realizada, como spread y como ratio, rankeado a lo largo de todo el universo.

¿Y por qué debería pagarte ese gap? Porque existe un vínculo teórico directo entre el gap y el P&L esperado. Para un straddle corto cubierto en delta, la contabilidad por unidad de tiempo es, a primer orden:

\mathbb{E}[\Pi] \;\approx\; \underbrace{\vphantom{\tfrac{1}{2}}\Theta\,\Delta t}_{\text{lo que cobras}} \;-\; \underbrace{\tfrac{1}{2}\,\Gamma\, S^2\,\sigma_r^2\,\Delta t}_{\text{lo que pagas}} \;=\; \tfrac{1}{2}\,\Gamma\, S^2\,\bigl(\sigma_i^2 - \sigma_r^2\bigr)\,\Delta t

Fíjate en el detalle que casi nadie comenta: el edge esperado es proporcional a la diferencia de varianzas, no de volatilidades. Eso significa que crece con el cuadrado del gap: un ratio de 1.5 no es un 50% más de edge que 1.0, es $(1.5^2 - 1) = 1.25$ unidades de varianza contra $(1.1^2 - 1) = 0.21$ . Casi seis veces más. Por eso el filtro de "riqueza" no es cosmético: es la diferencia entre operar con viento a favor o remar contra la corriente.

Los datos lo confirman con una claridad incómoda. Alineando la reversión forward por bucket de ratio IV/HV, vender vol donde el ratio está por debajo de 1 sangra — los nombres baratos siguieron subiendo de vol. El edge del vendedor solo se enciende por encima de 1.0, y en el extremo más rico, alrededor de 1.5×, el corto capturó unos 7 puntos de vol de reversión:

El edge del vendedor es un interruptor, no un dial: apagado bajo 1.0, y tanto más grande cuanto más ancha la brecha implícita-realizada. Números del estudio de Alphanume.

¿Cara para este nombre? IV Rank

La segunda acepción es cara respecto a su propia historia. Una vol de 48 que vive en el percentil 95 de su rango anual es un animal muy distinto de una vol de 48 que ha sido el suelo todo el año. La herramienta es el IV Rank: la implícita de hoy (y la realizada) colocada dentro de la banda trailing de 52 semanas del propio nombre, como un rank de 0 a 100:

IVRank_t = \frac{IV_t - \min\limits_{252}(IV)}{\max\limits_{252}(IV) - \min\limits_{252}(IV)} \times 100

Ojo con no confundirlo con el IV Percentile, que cuenta la fracción de días por debajo del nivel actual:

IVPct_t = \frac{1}{252}\sum_{i=1}^{252} \mathbb{1}\{IV_{t-i} < IV_t\} \times 100

El rank te dice dónde estás dentro del rango; el percentile te dice cuánto tiempo has pasado por debajo. Tras un único spike violento, el rank puede marcar 95 mientras el percentile se queda en 60. Para cazar estiramientos extremos, el rank es el instrumento más sensible.

Y la reversión, medida desde el rank, es brutalmente limpia. El estudio agrupó cada nombre del universo por su IV rank y miró qué hizo su implícita a 30 días durante el mes siguiente. El patrón es de lo más monocromo que verás en mercados:

Reversión por decil de IV Rank, universo de nombres opcionables (estudio Alphanume): los que entran en el decil superior de su propio rango ven caer su implícita ~-18% en un mes; los del decil inferior la ven subir ~+32%. Casi lineal de punta a punta.

Cuanto más alto el rank, más fuerte tira la reversión. Esta es la señal que hay debajo de la intuición de todo el mundo, hecha medible.

Apilando el edge: el screen completo

Junta las dos patas y la corazonada se convierte en un screen robusto. La versión insignia es el conditioned premium sell, y corre en cinco pasos:

El embudo: universo completo → solo ricos (ratio ≥ 1.25) → solo estirados (IV rank ≥ 70) → estructura dimensionada al rango implícito → cosecha. Recuentos ilustrativos.

Universo: el feed IV/HV Premium del día, solo filas asentadas (only_final=true), para no operar sobre un print intradía provisional.
Riqueza: filtra a lo alto de la distribución del ratio IV/HV (min_ratio_rank=1.25 o más). Es la puerta de "¿me están pagando de verdad?".
Estiramiento: cruza con IV Rank y quédate solo con nombres altos en su propia banda trailing (min_iv_rank=70). Es el brazo de "¿es probable la reversión?".
Estructura: el corto como strangle o iron condor alrededor del rango implícito ATM, dimensionado al movimiento que la cadena implica — no a tu convicción. Los breakevens de un straddle son $BE_{\pm} = K \pm (C + P)$ ; la estructura debe respetarlos, no tu entusiasmo.
Cosecha: deja que la reversión trabaje las semanas siguientes, mientras la vol rica y estirada hace lo que la vol rica y estirada hace.

La diferencia entre correr este screen y vender lo que "parezca alto" no es teórica. Midiendo los puntos de vol capturados al ponerse corto de vol a 30 días y mantener un mes, según cómo filtras:

La escalera: vender todo indiscriminadamente captura ~0 — un coin-flip puro. Filtrar por riqueza: +4.6 puntos. Apilar el IV rank encima: +12.5, casi el triple. Cada filtro es un número de un feed, y cada uno apila.

Este es, honestamente, todo el argumento. El mecanismo general de vender vol implícita alta nunca fue un secreto ni algo propietario. Lo que no podías hacer sin los datos es condicionar la operación lo bastante fino como para estar del lado correcto.

Vol-of-Vol: el tercer número

Queda una pregunta que las dos primeras no pueden responder: una vez dentro, ¿cómo de violento será el viaje?

Eso es la Vol-of-Vol — el $\xi$ del proceso de OU con el que abrimos. Mide la inestabilidad de la vol del propio nombre, por ejemplo como la desviación estándar de los cambios diarios de la implícita en la ventana trailing:

VoV_t = \operatorname{sd}_{21}\bigl(\Delta IV_t\bigr)

Una lectura baja: la vol está bien educada, muele alrededor de un nivel. Una lectura alta: la vol va dando latigazos, saltando entre regímenes. Mismo corto (ricos + alto rank), partido por vol-of-vol:

La misma estrategia, dos temperamentos. Nombres de vol estable: distribución estrecha alrededor de una ganancia modesta, ~83% de aciertos. Nombres de vol inestable: capturan más de media, ganan más a menudo (>90%), pero con un abanico de resultados mucho más salvaje, estirado hacia la derecha.

La vol-of-vol es, en la práctica, un dial de sizing que te dice a qué tipo de operación te estás apuntando:

VoV baja → ingreso estable tipo theta. Reversiones más pequeñas, pero puedes dimensionarlas grandes y dormir durante el proceso.
VoV alta → aquí viven los grandes snapbacks, porque la vol se estiró violentamente para empezar. Pagan más y aciertan más a menudo, pero también te regalarán una semana o dos de retortijones antes de resolver. Dimensiona pequeño.

Hay más que vender vol: el lado largo

Cuando sale el tema de operar volatilidad, la conversación casi siempre se sesga a vender y cobrar prima. Pero si le das la vuelta a cada signo, la misma maquinaria te señala qué vol comprar.

Cuando un nombre se sienta en el decil inferior de su IV rank, la misma matemática de reversión dice que su implícita sube ~+32% el mes siguiente. Es el setup clásico de long-gamma: vol barata respecto a su propia historia, con el tirón hacia arriba la mayoría de las veces.

La versión más fina cruza IV rank con HV rank: cuando la implícita araña el suelo de su rango mientras la realizada ya empieza a arrastrarse por encima, estás ante un nombre cuyas opciones están precificadas para una calma que la acción ha dejado de entregar discretamente. Largo el straddle — o lo que te dé el gamma más limpio — y deja que la implícita persiga a la realizada que ya se está moviendo:

El trade espejo. Izquierda: el decil inferior del rank es donde la vol barata deriva hacia arriba. Derecha: el setup soñado del comprador — implícita en el suelo, realizada ya reptando por encima.

Validación independiente con datos reales

Los números del estudio vienen de un feed propietario (Alphanume). ¿Se reproduce el patrón con datos públicos? Lo comprobamos con la serie oficial del VIX del CBOE — 2,711 observaciones entre 2015 y 2026 — aplicando exactamente la misma mecánica: rank de 252 días del VIX, deciles, y cambio forward a 21 días:

Nuestra propia réplica sobre el VIX (datos oficiales CBOE, 2015–2026): misma forma que el estudio por nombres. El decil superior del rank pierde de media -13.7% en el mes siguiente — y el 77.9% de esas observaciones son negativas —; el inferior gana +11.7%, con el 72.8% de observaciones positivas. Monótono casi de punta a punta.

La estructura es la misma que en el universo de acciones: cuanto más estirado está el índice de miedo dentro de su propio rango, más fuerte tira la reversión. Distinto instrumento, distinta fuente de datos, misma ley.

Nota de método: lo que esto es y lo que no es

Estos son pulls reales de datos, no un backtest llave en mano. La reversión medida es un mark-to-market sobre la propia vol en una ventana forward de un mes. El camino realizado y los costes de ejecución son riesgos vivos que se sientan encima del movimiento de la vol — y la sección de vol-of-vol trata precisamente de respetar el primero.

Traducción a griego llano: aunque la implícita caiga como predice el rank, un straddle corto puede perder dinero si la acción se mueve más que lo que la vol cayó. La ecuación del P&L no miente:

\Pi \approx \tfrac{1}{2}\,\Gamma S^2\bigl(\sigma_i^2 - \sigma_r^2\bigr)\Delta t - \text{costes}

y $\sigma_r$ es una realización, no una promesa. El punto de esta investigación es el filtrado apropiado y la demostración de que estas tres cifras mueven las probabilidades de forma medible y apilable. Lo que construyas encima es la parte divertida.

Conclusión: tres preguntas, tres números

Todo el mundo sabe que la vol revierte a la media. Ese conocimiento, por sí solo, no vale casi nada — y por eso tanta gente vende vol "alta" y aun así consigue perder.

El edge está en saber, antes de comprometer un dólar:

Pregunta	Número	Umbral del estudio
¿Me están pagando de verdad?	IV/HV Premium — ratio $\rho = IV/HV$	$\rho \gtrsim 1.25$ (edge muere bajo 1.0)
¿Está estirada en su propio rango?	IV Rank (0–100, 52 semanas)	$\geq 70$ (D10 revierte ~-18%/mes)
¿Cómo de duro será el viaje?	Vol-of-Vol — $\operatorname{sd}_{21}(\Delta IV)$	dial de sizing, no de entrada

Si alguna vez vendiste un straddle a corazonadas y lo viste saltar en tu contra, ya sabes exactamente cuánto valen estas tres cifras.

Este artículo expande el estudio "A Common Sense Guide to Volatility Trading" de Quant Galore × Alphanume Research (junio 2026). Las cifras del estudio por deciles, ratio y filtros son las reportadas por ellos, redibujadas con nuestro estilo; la validación sobre VIX es cálculo propio con datos oficiales del CBOE. Nada de esto es consejo de inversión.

Código: réplica completa

El estudio original publica sus scripts en el Strategy Lab de Quant Galore (carpeta Stock Volatility Trading) usando la API de Alphanume. Aquí va nuestra versión autocontenida, con datos 100% públicos, que reproduce el gráfico de validación del VIX de arriba y deja montada la caja de herramientas (HV close-to-close, Parkinson, IV Rank, Vol-of-Vol) para aplicar a cualquier nombre:

python

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# ---------------------------------------------------------------
# TOOLBOX: realized vol, IV rank, vol-of-vol
# ---------------------------------------------------------------
def hv_close_to_close(px: pd.Series, window: int = 30) -> pd.Series:
    """Annualized close-to-close realized vol."""
    r = np.log(px / px.shift(1))
    return np.sqrt(252.0 / window * (r**2).rolling(window).sum())

def hv_parkinson(high: pd.Series, low: pd.Series, window: int = 30) -> pd.Series:
    """Annualized Parkinson (high-low range) realized vol."""
    hl = np.log(high / low) ** 2
    return np.sqrt(252.0 / window * (hl / (4 * np.log(2))).rolling(window).sum())

def iv_rank(iv: pd.Series, window: int = 252) -> pd.Series:
    """Position of today's vol inside its own trailing range, 0-100."""
    lo, hi = iv.rolling(window).min(), iv.rolling(window).max()
    return (iv - lo) / (hi - lo) * 100

def vol_of_vol(iv: pd.Series, window: int = 21) -> pd.Series:
    """Instability of vol itself: sd of daily IV changes."""
    return iv.diff().rolling(window).std()

# ---------------------------------------------------------------
# STUDY: VIX 252d-rank deciles -> forward 21d change (CBOE data)
# ---------------------------------------------------------------
URL = "https://cdn.cboe.com/api/global/us_indices/daily_prices/VIX_History.csv"
vix = pd.read_csv(URL, parse_dates=["DATE"])
vix = vix[vix["DATE"] >= "2015-01-01"].reset_index(drop=True)

c = vix["CLOSE"].astype(float)
rank = iv_rank(c, window=252)                 # VIX vs its own 52w range
fwd = c.shift(-21) / c - 1                    # forward 1M (~21 trading days)

df = pd.DataFrame({"rank": rank, "fwd": fwd}).dropna()
df["decile"] = pd.qcut(df["rank"], 10, labels=False) + 1

g = df.groupby("decile")["fwd"].mean() * 100
print(g.round(2))
print("top decile, share negative :",
      round((df[df.decile == 10]["fwd"] < 0).mean() * 100, 1), "%")
print("bottom decile, share positive :",
      round((df[df.decile == 1]["fwd"] > 0).mean() * 100, 1), "%")

g.plot(kind="bar", color=["#2d7ff9" if v > 0 else "#ff6e1a" for v in g])
plt.ylabel("mean fwd 21d dVIX (%)"); plt.xlabel("VIX rank decile")
plt.axhline(0, color="grey", lw=1); plt.show()

Salida esperada (los números del gráfico de validación):

text

decile
1     11.67
2     12.84
3     10.51
4      9.87
5      8.65
6      4.88
7      0.39
8      0.04
9     -5.74
10   -13.69
top decile, share negative : 77.9 %
bottom decile, share positive : 72.8 %

Para llevarlo a acciones individuales solo necesitas una fuente de vol implícita a 30 días por nombre (la de tu broker, ORATS, o la API de Alphanume con una key gratuita) y cruzarla con el OHLC diario: hv_close_to_close te da la realizada, iv_rank el estiramiento, vol_of_vol el temperamento. El screen completo es literalmente tres líneas de pandas sobre esas columnas — el resto es disciplina.

Siguientes pasos

Si quieres profundizar en cómo medir y presupuestar el riesgo de cola de forma rigurosa dentro de un flujo sistemático, el curso abierto QAO — Riesgo cuantitativo: VaR y Expected Shortfall cubre el marco completo con código real.

System 7 (parte 2): nos fuimos al heads-up, y el explotador por fin cobró

Jesus Cuesta — Sun, 05 Jul 2026 21:03:34 GMT

En la primera parte terminamos con una lección incómoda: construimos un motor explotador elaboradísimo —clasificación de manos, filtros matemáticos, node-locking, un LLM para los nudos difíciles— y perdió. Contra el panel de referencia, el node-locking heurístico puro hacía −9.75 bb/100 y la versión híbrida con LLM −1.66 bb/100. Lo que ganaba, y por goleada, era la táctica más tonta imaginable: abrir muchísimo y robar ciegas sin complejos. +119 bb/100 con una estrategia que cabe en una servilleta.

La moraleja de aquella entrega fue que el motor le gana a la idea brillante: la ventaja no está en la jugada genial, sino en el bucle de autor → test → comparar → desplegar → coach → repetir. Y que la explotación solo paga cuando hay una fuga real que explotar.

Lo que no contamos —porque todavía no había pasado— es qué ocurre cuando le das a ese motor un rival de verdad al que apuntar. Esta es esa historia. Desde entonces cambiamos de mesa, reescribimos medio motor, lo metimos en Docker y aprendimos, a base de golpes, que en producción la fiabilidad es una habilidad de póker más.

Recapitulando: dónde lo dejamos

Para quien llegue nuevo: System 7 es un agente de No-Limit Hold'em que juega en el Arena de dev.fun, un torneo donde agentes de software se enfrentan entre sí (y a humanos). El núcleo es Python determinista —rápido, reproducible, testeable— con un "cerebro" LLM (MiniMax M3) al que solo llamamos para los nudos difíciles. Todo está abierto en GitHub.

La parte 1 se jugó en mesas de 6-max. El diagnóstico honesto fue que el panel de referencia, aunque teóricamente sólido, tenía una fuga estructural: foldeaba demasiado preflop. Nuestra maquinaria de microscopio no hacía falta; bastaba un martillo. Pero un 6-max reparte la culpa entre cinco rivales y trocea la muestra: nunca ves suficientes manos de un mismo villano como para explotarlo con confianza. El microscopio no tenía a quién enfocar.

Así que hicimos lo obvio que no habíamos hecho: quitamos a cuatro jugadores de la mesa.

El giro al heads-up (temporada S4)

El heads-up —uno contra uno— lo cambia todo, y no por romanticismo. Lo cambia por estadística. En 6-max, 500 manos son ~80 manos de cada rival: ruido. En heads-up, 500 manos son 500 manos del mismo rival. Por fin la muestra crece lo bastante rápido como para que "este tío foldea demasiado a la 3-bet" pase de corazonada a número con intervalo de confianza.

6-max: ~80 manos/rival. Heads-up: ~500 del mismo rival

\text{SPR} = \frac{\text{Effective stack}}{\text{Pot}}

Toda la temporada S4 la dedicamos a rehacer el motor pensando en un solo oponente. En términos de repo, esto fue la v0.6.0: activación de node-locking, EV en all-in, un coach específico de heads-up y un panel unificado. Pero la frase de una línea esconde el cambio de mentalidad: dejamos de preguntar "¿cuál es la jugada correcta contra el campo?" y empezamos a preguntar "¿cuál es la jugada correcta contra este que llevo 1.500 manos mirando?".

Es exactamente la tesis de la parte 1 —explotar en lugar de jugar equilibrio— pero por fin con el terreno a favor.

Node-locking que por fin paga

El node-locking, recordemos, es fijar (clavar, lock) una parte de la estrategia del rival según lo que has observado, y recalcular tu respuesta óptima contra esa fuga concreta. En la parte 1 era, en la práctica, un adorno caro: la muestra no daba para fiarse del lock.

En heads-up sí da. Calibramos el umbral de adaptación a ~1.900 manos por oponente, que es el orden de magnitud que el Arena reparte en una sesión seria. Por debajo de eso, jugamos base sólida y no nos inventamos reads. Por encima, el motor empieza a explotar de verdad los arquetipos clásicos:

NIT — el que solo juega manos premium: le robamos las ciegas sin descanso y le pagamos poquísimo cuando por fin despierta.
STATION — el que paga todo: dejamos de farolear y engordamos el valor. Aquí el farol es literalmente prender dinero.
LAG — el agresivo suelto: le devolvemos la agresión donde la matemática aguanta y le tendemos trampas en los nudos.
MANIAC — la versión extrema: paciencia, trampas y dejar que se estrelle solo.

Con esto vinieron dos ajustes finos que suenan a poco y valen mucho. Primero, ampliamos el rango de c-bet en botón a boards coordinados: en heads-up, la iniciativa vale, y ceder demasiado te convierte en el NIT que quieres explotar. Segundo, arreglamos una fuga propia que llevábamos arrastrando: las parejas bajas en boards emparejados (una pareja de menos frente a, digamos, KK en el board) dejaron de tratarse como manos de compromiso y pasaron a clasificarse como lo que son, bluff-catchers. Es una corrección pequeña de una tabla de clasificación de manos, y de esas viven o mueren los bb/100.

python

def _archetype(st: dict) -> str:
    """Classify a villain from agent-stats. N-gated by sampleSize."""
    n = int(st.get("N") or 0)
    if n < 500:                    # too few hands -> don't trust the read
        return "UNKNOWN"
    vpip, pfr = _pct(st["vpid"]), _pct(st["pfr"])
    gap = vpip - pfr
    if vpip >= 30 and gap >= 15:   return "STATION"   # calls everything
    if vpip >= 40 and pfr >= 30:   return "MANIAC"    # ultra-aggressive
    if vpip <= 15 and gap <= 6:    return "NIT"       # only premiums
    if vpip >= 26 and pfr >= 20:   return "LAG"        # loose-aggressive
    return "TAG"                                          # solid default

Todo el afinado vive en system7-hu.json: tamaños de apertura, frecuencias de barril, 3-bets de farol y rangos de ciega pequeña. Estrategia como dato, versionada, intercambiable con una variable de entorno. Ese diseño —lo prometimos en la parte 1— es lo que hace que iterar sea barato.

Motor v1.5: la lógica de supervivencia

Y aquí llegamos a lo de hoy mismo. La v0.7.0, publicada esta misma tarde, trae lo que internamente llamamos motor v1.5, "supervivencia". Es el cambio conceptual más grande desde la parte 1, y nace de una observación fea: un motor optimizado para maximizar EV en cada mano toma decisiones estupendas para el largo plazo y ruinosas para seguir en la mesa.

El ejemplo canónico es AKo. Contra un solo rival, meter la pila con AKo suele estar bien. Pero en secuencias multiway de 4-bet/5-bet, meterla plano con AKo es tirar fichas: cuando entra tanto dinero de tanta gente, tu mano preciosa es, con demasiada frecuencia, la segunda mejor. El motor v1.5 deja de hacerlo.

La pieza nueva son los niveles de compromiso —shallow / deep / all-in— indexados por la profundidad de la re-subida. En vez de una regla uniforme de "con esta fuerza, voy con todo", el compromiso se gradúa por tramo: cuanto más se recrudece la guerra de re-raises, más selectiva se vuelve la mano con la que aceptas jugarte la pila. En multiway, además, las parejas dejan de comprometerse automáticamente en SPR bajo. El comportamiento en heads-up puro se conserva intacto: allí seguimos jugando a maximizar.

Dos detalles de ingeniería que importan más de lo que parece. Todo esto está detrás de un flag, survival:true: por defecto el comportamiento no cambia, así que nadie se lleva sorpresas y podemos hacer A/B contra el motor anterior. Y llegó acompañado de 18 tests nuevos. Porque una regla de compromiso mal escrita no falla ruidosamente: falla silenciosamente, una pila cada varias horas, justo del tipo de fuga que la parte 1 nos enseñó a temer.

Supervivencia no es lo contrario de maximización. Es reconocer que en un formato con escalera y temporadas, seguir jugando tiene un valor que la EV mano a mano no captura.

python

def _commit_tier(seats, seat_n, hero_bet, call_chips, eff, bb):
    """Commitment depth -> how much stack to risk.
    'shallow' (1st 3-bet) -> 'deep' (4-bet) -> 'allin' (5-bet+/jam)."""
    thr = max(KN["commit_4bet_bb"] * bb, 0.2 * eff)
    n_committed = sum(1 for s in seats
                      if s["seatNumber"] != seat_n
                      and (is_allin(s) or s.get("currentBetChips", 0) >= thr))
    risk = call_chips / max(eff, 1)
    hb = hero_bet / bb if bb else 0
    if n_committed >= 2 or risk >= 0.6 or hb >= 22:
        return "allin", n_committed
    if hb >= 8 or risk >= 0.35:
        return "deep", n_committed
    return "shallow", n_committed

Niveles de compromiso: shallow, deep, all-in

\text{EV}_{\text{total}} = \text{EV}_{\text{hand}} + \text{EV}_{\text{survival}}

Equity por temporada, escalera heads-up y auto-reanudación

La v0.7.0 trae además tres piezas menos glamurosas y absolutamente necesarias:

Equity por temporada. Antes, las curvas de equity mezclaban manos de competiciones distintas y te pintaban un dibujo mentiroso. Ahora la curva se acota por competition_id: cada temporada, su gráfica. Suena a contabilidad, y lo es —pero medir bien fue el tema central de la parte 1, y mezclar temporadas es exactamente la clase de autoengaño estadístico contra el que predicábamos.

Escalera heads-up (el ladder bot). Empaquetamos un agente estático en su propio directorio ladder/, con un adaptador defensivo y la librería treys vendorizada dentro. ¿Por qué? Porque el sandbox donde corren algunos agentes no tiene sistema de archivos ni forma de instalar dependencias. Un agente con cero dependencias de disco es un agente que arranca donde sea. Es la diferencia entre "funciona en mi máquina" y "funciona en la suya".

Auto-reanudación de PvP. El bucle de juego persiste su estado en data/prod_resume.json y sobrevive a reinicios del host, recreaciones del contenedor y caídas de subprocesos. Antes, un reinicio a deshora te dejaba una partida a medias y un hueco en los datos. Ahora se levanta solo y sigue donde estaba. Esto conecta directamente con la siguiente sección, porque aprendimos a valorarlo por las malas.

Curva de equity por temporada: habilidad vs varianza

\text{EV}_{\text{ICM}} = \sum_{i=1}^{n} P(\text{place } i) \times \text{Payout}(i)

python

# PvP auto-resume — survive restarts
RESUME_FILE = "data/prod_resume.json"

def save_state(table_id, hand_num):
    with open(RESUME_FILE, "w") as f:
        json.dump({"table_id": table_id, "hand": hand_num,
                   "ts": time.time()}, f)

def resume():
    try:
        with open(RESUME_FILE) as f:
            return json.load(f)
    except FileNotFoundError:
        return None  # fresh start

Del código a la trinchera: historias de producción

La parte 1 terminaba en el "tooling": el panel de tres zonas (LAB / COACH / PRODUCCIÓN). Lo que no contaba es lo que cuesta tener eso vivo semana tras semana. Spoiler: en un torneo online, la fiabilidad operativa es una habilidad de póker más. Estas son las cicatrices.

Docker, y el pecado de recrear el contenedor. El despliegue vivo es Docker en /opt/arena-system7-llm (imagen system7-poker-arena:latest, dashboard en el puerto 8787, restart: unless-stopped). Aprendimos la regla más cara del proyecto: nunca hagas up -d --force-recreate con jobs en vuelo. Los Eval y los PvP son subprocesos hijos del dashboard; recrear el contenedor los mata en seco, y te quedas con evaluaciones a medias y una carpeta .clasif vacía. Horas de partidas convertidas en nada por un despliegue impaciente.

yaml

# docker-compose.yml — dashboard + optional workers
services:
  dashboard:
    build: .
    image: system7-poker-arena:latest
    command: ["dashboard"]
    ports: ["8787:8787"]
    volumes: ["./data:/data"]
    restart: unless-stopped
    environment:
      S7_STATS_DB: /data/s7_cash.db
      S7_RUN_BACKEND: subprocess

  bench:                          # optional: continuous Eval
    command: ["bench"]
    profiles: ["bench"]
    environment:
      S7_ENGINE: hybrid
      S7_MATCHES: "50"

El WAL que se comió el disco. SQLite en modo WAL es maravilloso hasta que un job se atasca y el write-ahead log crece a gigabytes. Nos pasó. El hardening fue a base de tres candados: journal_size_limit para que el WAL no crezca sin freno, un timeout por match para que ningún job se quede colgado eternamente, y un lock de instancia única para que no haya dos procesos peleándose por la misma base de datos. Nada de esto es póker. Todo esto es lo que te permite jugar al póker.

python

# SQLite WAL hardening — three locks against runaway growth
conn = sqlite3.connect("s7_cash.db")
conn.execute("PRAGMA journal_mode = WAL")
conn.execute("PRAGMA journal_size_limit = 67108864")  # 64 MB cap
conn.execute("PRAGMA busy_timeout = 30000")            # 30s lock wait
conn.execute("PRAGMA wal_autocheckpoint = 1000")       # checkpoint every 1000 pages

El self-play local miente. Uno pensaría que la forma sensata de medir un motor es enfrentarlo contra sí mismo en local. No: el self-play del kit no mide bien la fuerza por posición, porque clava al héroe en la ciega pequeña y sesga el HUD. La fuerza real de un motor solo se mide en vivo, en el Eval y el PvP del Arena. Otra lección de humildad estadística, de las que ya coleccionamos.

El cuello de botella no era el que creíamos. Subimos los recursos en caliente a 6 cores / 4 GB. Y la intuición de ingeniero —"si va lento, es la CPU"— resultó falsa: cada partida con M3 come ~170 MB de RAM, y el verdadero cuello es la RAM y el tempo en tiempo real del Arena, no el cómputo. El motor determinista responde en milisegundos; lo que marca el ritmo es la mesa. Por cierto, las llamadas al LLM van sobre planes de tokens de MiniMax/Xiaomi, con las claves en .env —nada de proveedores hardcodeados.

El coach que se mejora solo

La pieza que más ha madurado es el coach. En la parte 1 era, sobre todo, un diagnosticador con reviews de manos vía LLM. Ahora es un bucle que se mejora a sí mismo: M3 lee los informes de estadísticas, detecta fugas y propone nuevas versiones de estrategia —esos JSON versionados— para que las probemos en A/B. El humano sigue en el asiento del conductor (aprobando o descartando versiones), pero el trabajo de "aquí hay un patrón, prueba a subir esta frecuencia" lo hace la máquina.

En heads-up el coach se volvió consciente de la posición: objetivos distintos para el botón (SB) y para la defensa de ciega grande, activándose a partir de las 500 manos y avisando cuando el diagnóstico se queda obsoleto porque llevas demasiadas manos sin actualizar la estrategia desplegada. Es el mismo principio de siempre: no confíes en un read viejo.

M3 lee stats, propone estrategia, A/B test, deploy

json

// strategies/system7-hu.json — heads-up tuning
{
  "survival": true,
  "game": "cash",
  "commit_value":       ["AA","KK","QQ","JJ","TT","AKs","AKo","AQs"],
  "commit_value_deep":  ["AA","KK","QQ","AKs"],
  "commit_value_allin":  ["AA","KK"],
  "knobs": {
    "commit_spr": 3,
    "commit_4bet_bb": 8,
    "commit_5bet_bb": 22,
    "commit_multi_n": 2
  }
}

Resultados honestos, otra vez

Aquí es donde nos toca ser fieles a nosotros mismos. En la parte 1 pusimos números concretos porque los teníamos, con sus intervalos de confianza de ±20 bb/100 y todo. En esta entrega no vamos a inventarnos un winrate de heads-up para cerrar bonito, porque la medición seria de esta temporada sigue viva y no queremos venderte ruido disfrazado de señal.

Lo que sí podemos decir con honestidad es direccional: el node-locking, que en 6-max era decoración, en heads-up tiene a quién apuntar y se comporta como debe contra los arquetipos. El motor v1.5 sangra menos en los multiway marginales. Y las curvas de equity —ahora separadas por temporada, con su línea de habilidad (sólida) y su línea de varianza (discontinua)— por fin cuentan una historia que no está contaminada por manos de otra competición.

El resto lo dirá la muestra, cuando la muestra sea muestra. Preferimos "seguimos vivos e iterando" a un titular con un número grande y un intervalo de confianza vergonzoso. Esa disciplina fue el corazón de la parte 1, y no pensamos abandonarla ahora que las cosas empiezan a salir.

Lo que nos llevamos (parte 2)

La explotación necesita un blanco. Toda la maquinaria de la parte 1 era correcta; le faltaba un rival al que enfocar el microscopio. El heads-up se lo dio. La idea no estaba mal; estaba mal la mesa.
Supervivencia no es lo contrario de maximizar. Optimizar cada mano en el vacío te hace perder pilas que importan. El motor v1.5 sacrifica algo de EV puntual a cambio de seguir en pie, y en un formato con escalera eso es EV de verdad.
La fiabilidad es una habilidad de póker. Un WAL desbocado, un --force-recreate a destiempo o un reinicio sin auto-reanudación te cuestan tantas fichas como una mala línea. En un torneo online, el uptime juega manos.
El bucle sigue ganándole a la idea. Como en la parte 1: autor → test → desplegar → coach → repetir. El coach que ahora propone estrategias no es magia; es el mismo bucle, con un peldaño más automatizado.

Seguimos vivos en el Arena. Y por primera vez, el explotador que escribimos con tanto mimo tiene delante a alguien a quien explotar.

Recursos y enlaces

Código (v0.7.0): github.com/quantarmyz/system7-poker-arena — motor determinista, híbrido con LLM, dashboard y tooling.
Plataforma: dev.fun · arena.dev.fun
Modelo de razonamiento: MiniMax (M3)
Parte 1: System 7: enseñamos a una IA a exploitar el póker
Y por la casa: rat-talks.com · unespeculador.com · pythonparatrading.com

El proyecto sigue vivo en el Arena. Si te interesa el cruce entre IA, teoría de juegos y decisión bajo incertidumbre, el repo está abierto y las cicatrices, documentadas.

System 7: enseñamos a una IA a explotar el póker — y lo que de verdad ganó fue otra cosa

Jesus Cuesta — Sun, 21 Jun 2026 20:44:05 GMT

Crónica técnica de construir un agente de póker para el Arena de dev.fun: el método heurístico, los LLM en la mesa, y los resultados honestos — incluidos los que no esperábamos.

El experimento

En dev.fun hay un sitio donde agentes de inteligencia artificial se sientan a una mesa de Texas Hold'em No Limit y juegan unos contra otros. No es una demo: hay manos reales, fichas reales, rivales reales (algunos humanos detrás de un bot, otros bots a secas) y, en los torneos, dinero on-chain en juego.

La pregunta que nos hicimos es engañosamente simple: ¿cómo construyes un agente que gane?

La respuesta corta, después de meses de código, miles de manos y un panel de control que acabó pareciendo la sala de un fondo cuantitativo, es esta: construimos una máquina sofisticadísima para explotar a los rivales… y lo que de verdad batió al adversario más duro fue una idea tonta de tan simple. Este post es la historia larga de cómo llegamos ahí, qué aprendimos del póker, de los LLM y de medir las cosas con honestidad.

dev.fun y el Arena

El Arena de dev.fun es una competición de agentes de póker. Tu agente es un programa que habla con una API en tiempo real. El bucle es siempre el mismo:

join — te sientas en una mesa.
pending-actions — la API te dice "es tu turno, esta es la situación" (tus cartas, el board, las apuestas, las fichas, quién ha hecho qué).
action — respondes: fold, check, call, bet, raise y cuánto.

python

# System 7 — game loop against the Arena API
client = ArenaClient(base_url, api_key=ARENA_API_KEY)
client.join(table_id)                          # 1. take a seat

while True:
    table = client.pending_actions(table_id)   # 2. "your turn, here's the situation"
    decision = hybrid.decide(table, deadline_s=30)
    client.action(table_id,                    # 3. respond: fold/check/call/bet/raise
                  action=decision["action"],
                  amount=decision.get("amount"))

El bucle de juego: join, pending-actions, action

Hay un deadline por decisión: si no contestas a tiempo, te hacen auto-fold. Es póker de verdad, con su reloj.

El Arena tiene tres "pistas", y entender la diferencia es clave porque cada una premia cosas distintas:

Eval — tu agente juega 500 manos contra un panel fijo de cinco bots de referencia. Es un benchmark: te puntúa en bb/100 (ciegas grandes ganadas por cada 100 manos, la métrica universal del póker) y te coloca en un ranking. No reparte premio y es de una sola tirada por agente. Aquí no te enfrentas a peces: el panel es lo más cercano a un rival "perfecto" que vas a ver.
Playground — PvP con dinero de juguete, gratis y continuo. Aquí sí hay rivales reales, con sus manías y sus fugas.
Tournament — un MTT (torneo multi-mesa) con entrada on-chain (cadena Monad, token MON): pagas una vez, recibes un stack fijo y compites en mesas de 2 a 6 jugadores que se van fundiendo hasta que queda un campeón.

Esa distinción — un rival casi perfecto (Eval) frente a rivales con fugas (Playground/Torneo) — es el eje de todo lo que viene.

Dos formas de jugar: GTO contra explotación

En el póker moderno conviven dos filosofías.

GTO (Game Theory Optimal). Juegas el equilibrio de Nash: una estrategia inexplotable. Hagas lo que hagas, no pierdes a la larga, porque mezclas tus jugadas de forma que el rival nunca puede sacarte ventaja. Es lo que aproximan los solvers y las redes entrenadas con Counterfactual Regret Minimization (CFR/DeepCFR). El GTO no intenta ganarte mucho; intenta no perder nunca.

Explotación. Renuncias a parte de esa coraza para castigar los errores concretos del rival. ¿Foldea demasiado a las subidas? Faroleas más. ¿Paga con cualquier cosa? Dejas de farolear y subes el valor. Es la forma en que piensan los profesionales humanos: el equilibrio es la base, pero el dinero está en las fugas del de enfrente.

Nuestra tesis de partida fue la del jugador explotador: usar el GTO como suelo defensivo y, a partir de ahí, desviarse agresivamente para exprimir cada debilidad. En la jerga, node-locking: "clavas" mentalmente el error del rival en un nodo del árbol de decisión y atacas justo ahí. Construimos un motor entero alrededor de esta idea. Se llama System 7.

GTO como suelo defensivo + desviaciones explotadoras

\sigma^* = \arg\min_{\sigma} \max_{\sigma'} u(\sigma', \sigma)

System 7: un motor explotador escrito a mano

Lo primero que hay que entender de System 7 es lo que no es: no es un LLM, y en el momento de decidir no llama a ninguna red ni a ningún modelo. Es Python puro y determinista —y código abierto en GitHub—. Recibe la mesa, hace cuentas y devuelve una jugada en milisegundos. Toda la "inteligencia" está codificada como reglas, destiladas de una metodología de juego explotador (la escuela de EducaPoker / "Estrategia Universidad", con la huella de jugadores como Raúl Mestre).

El motor se organiza en cuatro directivas.

D1 — Cuánto te fías de lo que ves (la muestra N). No puedes explotar a un rival del que no sabes nada. System 7 escala su agresividad según cuántas manos lleva observando al villano:

N < 100: ceguera. Ignora las estadísticas (puro ruido) y juega rangos estándar, respetando la agresión rival.
100 ≤ N < 500: empieza a perfilar por el gap entre VPIP (con qué frecuencia mete fichas) y PFR (con qué frecuencia sube). De ahí salen los arquetipos: Nit (tightísimo), TAG (sólido), LAG (agresivo y suelto), Calling Station (paga todo) y Maníaco. A cada uno se le juega distinto: a la station, tolerancia cero a los faroles y subir el valor; al nit, robarle las ciegas sin parar.
N ≥ 500: node-locking fino. Si el rival foldea a las resubidas más del 55% de las veces, le 3-beteamos cualquier mano con un As bloqueador. Si abandona el flop ante la apuesta de continuación más del 45%, le apostamos el 100% de nuestro rango con un sizing pequeño.

python

def _archetype(st: dict) -> str:
    """Classify a villain from agent-stats. N-gated by sampleSize."""
    n = int(st.get("N") or 0)
    if n < 500:                    # too few hands -> don't trust the read
        return "UNKNOWN"
    vpip, pfr = _pct(st["vpid"]), _pct(st["pfr"])
    gap = vpip - pfr
    if vpip >= 30 and gap >= 15:   return "STATION"   # calls everything
    if vpip >= 40 and pfr >= 30:   return "MANIAC"    # ultra-aggressive
    if vpip <= 15 and gap <= 6:    return "NIT"       # only premiums
    if vpip >= 26 and pfr >= 20:   return "LAG"        # loose-aggressive
    return "TAG"                                          # solid default

D2 — Qué tienes y dónde estás (la geometría). En lugar de pensar "tengo pareja de ases", System 7 clasifica la mano por su encaje relativo con el board: MMF (manos monstruo: sets, colores, escaleras), MF (manos fuertes: top pair con buen kicker, overpair), MM (manos medias), MD (manos débiles) y Aire/Proyectos. Y clasifica la mesa por textura: seca, semi-coordinada, coordinada y extremadamente coordinada (donde hasta un set baja de categoría porque el peligro es enorme). Encima añade la dinámica de las cartas que van saliendo: una carta scary (un As, un K que cierra un color) favorece al agresor y baja el umbral para farolear; una carta defensiva frena la agresión y pide control del bote.

D3 — La aritmética implacable (PME vs PER). Aquí no hay corazonadas. Calcula el PME (las pot odds: cuánto arriesgas frente a lo que puedes ganar) y lo compara con el PER (tu equity real, contando outs ajustadas por la textura — un proyecto de color vale menos si el rival puede tener uno mayor; las sobrecartas valen casi cero en una mesa muy coordinada). La regla es un mandato: si tu equity no cubre las pot odds, foldeas, salvo que el HUD certifique que el rival se va a tirar (entonces el farol tiene su propio valor).

python

def _pme(call_chips: int, pot: int) -> float:
    """Pot odds: what you risk vs what you can win."""
    tot = pot + call_chips
    return (call_chips / tot) if tot > 0 else 1.0

def _per(adj_outs: int, board_len: int) -> float:
    """Adjusted-outs equity (rule of 4/2)."""
    mult = 4 if board_len == 3 else (2 if board_len == 4 else 0)
    return min(0.95, adj_outs * mult / 100.0)

\text{PME} = \frac{\text{Call}}{\text{Pot} + \text{Call}}

\text{PER}_{\text{flop}} = \frac{\text{Outs} \times 4}{100}, \quad \text{PER}_{\text{turn}} = \frac{\text{Outs} \times 2}{100}

\text{Call if } \text{PER} \geq \text{PME}

D4 — El postflop y el "Perejil Asesino". Cuando el SPR (la relación entre el bote y las fichas que quedan) baja de 3, te comprometes con cualquier mano fuerte: el control del bote desaparece, vas con todo. Y para los faroles está el protocolo bautizado como "Perejil Asesino": un farol condicionado. Solo subes de farol si se cumplen condiciones (debilidad evidente del rival, un salvavidas de 8 a 10 outs reales que respalda la jugada por si te pagan, ajustes por número de rivales…). Nunca se farolea por impulso con basura; cada agresión va respaldada por matemática o por una fuga documentada.

Y por encima de todo, el HUD: un módulo que lee en vivo las estadísticas de los rivales (tamaño de muestra, VPIP, PFR, 3-bet, fold-to-cbet, showdown…), los clasifica en arquetipos y alimenta las desviaciones de la D1. El HUD es lo que convierte a System 7 de un robot disciplinado en un explotador.

python

# Strategy as versioned data — strategies/<name>.json
SIZING = {
    "dry":     {"flop": 0.33, "turn": 0.50, "river": 0.60},
    "semi":    {"flop": 0.50, "turn": 0.60, "river": 0.66},
    "coord":   {"flop": 0.66, "turn": 0.75, "river": 0.75},
    "extreme": {"flop": 0.75, "turn": 0.80, "river": 0.80},
}
# Toggle strategy: S7_STRAT=s7-opus uv run run_hybrid_system7.py

Es, en resumen, un intento serio y completo de codificar cómo piensa un profesional explotador. Funcionaba. La pregunta era: ¿ganaba?

Meter un LLM en la mesa

El motor heurístico es rápido y barato, pero tiene un techo: las reglas, por finas que sean, no cubren todos los spots raros. Así que probamos un motor híbrido: la heurística resuelve los spots triviales (la inmensa mayoría) y, en los spots difíciles, le pasa la decisión a un LLM que razona la jugada.

Usamos MiniMax M3, un modelo de razonamiento, con el propio System Prompt del método (las cuatro directivas, traducidas a lenguaje, más un contrato de salida en JSON). El LLM recibe la situación reconstruida y devuelve una jugada justificada. ¿El coste? Unos 27 segundos por decisión y un consumo de tokens nada trivial — por eso solo entra en los spots que de verdad lo merecen (gating por dificultad).

python

def _is_hard(table: dict, deadline_s: float) -> bool:
    """Gate: True => worth a slow LLM call (~27s)."""
    if deadline_s < 30:            # M3 takes ~27s; don't risk auto-fold
        return False
    board = list(table.get("boardCards") or [])
    if not board:                  # preflop: position ranges suffice
        return False
    texture = H._texture(board)
    strength = H._strength(hole, board, texture)
    outs = H._adjusted_outs(hole, board, texture)
    if strength == "MMF":         # clear value / commit
        return False
    if strength == "MM" or (strength in ("AIR", "MD") and outs >= 4):
        return True               # thin value / semi-bluff / give-up
    return False

Aquí aparece un tema que se ha vuelto central en todo el ecosistema de IA: los modelos de razonamiento. Un M3 o un DeepSeek-R1 "piensan en voz alta" antes de responder, lo que les da una ventaja real en problemas con muchas variables interdependientes — y el póker, en sus spots difíciles, es exactamente eso. Más adelante esto reaparece de forma elegante en nuestro propio coach.

Lo que pasó (y lo que no esperábamos)

Aquí viene la parte honesta, que es también la más interesante.

El panel del Eval — ese rival "casi perfecto" — resultó ser cinco clones idénticos de un bot DeepCFR: un TAG equilibrado (VPIP ~21.7, PFR ~16.4, factor de agresión ~1.95), sin fugas evidentes. Lo más parecido al GTO que íbamos a poder medir.

Medimos:

System 7 heurístico (node-locking puro): −9.75 bb/100.
Híbrido con M3 (razonando los spots difíciles): −1.66 bb/100.

Es decir: nuestra elaboradísima máquina de explotar perdía contra el panel. El LLM la mejoraba (de −9.75 a −1.66 — su razonamiento en spots difíciles ayudaba de verdad), pero ninguno de los dos batía al rival.

La lección, en una frase: no puedes sobre-explotar a alguien que no tiene fugas. Todo el aparato de node-locking — los arquetipos, el Perejil Asesino, las desviaciones finas — solo cobra cuando el rival comete errores sistemáticos. Contra un near-GTO sin leaks, esa maquinaria gira en el vacío e incluso te hace daño (te desvías del equilibrio sin recompensa).

Y entonces, el giro. Probamos una estrategia tonta de tan simple: rangos muy anchos y agresión de robo (abrir muchas más manos, robar ciegas sin freno). Contra el mismo panel, esa estrategia wide puntuó +119 bb/100 en las clasificatorias.

¿Por qué? Porque el panel, pese a ser "GTO", tenía una propiedad explotable: foldeaba alrededor del 78% de sus manos preflop. Hasta un bot disciplinado es, estructuralmente, demasiado tight. Y eso es una fuga — solo que no del tipo que el HUD detecta mano a mano, sino una estructural, que se castiga con la jugada más vieja del libro: robar.

Ahí está la ironía bonita del proyecto: la explotación sí ganó — pero el exploit correcto era el simple y estructural (robar), no la elaborada lectura multi-calle. Construimos un microscopio para encontrar fugas sutiles cuando lo que pagaba era un martillo.

Una nota de humildad estadística obligatoria: bb/100 sobre 500 manos tiene un intervalo de confianza de ±20. Tanto el −9.75 como el +119 son ruidosos en valor absoluto. Lo que sí fue consistente entre tiradas fue la dirección: contra este panel, anchura ≫ node-locking. Tratar un número de 500 manos como veredicto es uno de los errores más fáciles — y más caros — de cometer.

Node-locking -9.75 vs Wide +119 bb/100 (CI +-20)

\text{CI}_{95\%} \approx \pm \frac{200}{\sqrt{N/100}} \text{ bb/100}

\text{CI}_{95\%} \approx \pm \frac{200}{\sqrt{N/100}} \text{ bb/100}

¿Y dónde brilla, entonces, toda la maquinaria explotadora? Donde hay fugas de verdad: en el Playground y el Torneo, contra rivales reales que sí pagan de más, foldean de menos y farolean mal. Ahí el HUD y el node-locking dejan de girar en el vacío.

Del laboratorio a producción: el tooling

Un agente no es nada sin la fábrica que lo produce. La mitad del proyecto es un panel de control que organiza todo el ciclo de vida del agente en tres zonas:

LAB — donde naces una estrategia: una rejilla 13×13 (las 169 manos del póker) para pintar rangos a mano, elegir motor (heurístico / híbrido), modelo y HUD, y backtestear varios agentes a la vez (con la concurrencia capada para no reventar las APIs ni provocar rate-limits). El resultado se reporta como bb/100 agregado por estrategia, con su intervalo de confianza — no como un run suelto.
COACH — donde el agente aprende. Un diagnóstico de tu juego frente al óptimo (VPIP, PFR, c-bet… contra las bandas de referencia) y un coach LLM que critica tus manos y propone ajustes concretos. Lo último que añadimos: un coach mano a mano — coges tus 10 manos más y menos rentables, las seleccionas, y un modelo de razonamiento (DeepSeek-R1) te dice de cada una si la jugaste bien o mal y dónde está la fuga. (Curiosidad: el modelo de razonamiento es notablemente más crítico que el normal; donde el modelo estándar aplaude un all-in, el de razonamiento detecta que ese overbet espantaba las manos peores y solo cobraba a las mejores.)
PRODUCCIÓN — donde el agente compite: despliegue en vivo, curva de equity real frente a la EV teórica, un reproductor de manos para revisar cada jugada, y un tracker que perfila a los rivales.

Y todo esto cierra un bucle de auto-mejora: propones una versión → la testeas → la comparas contra el control → la despliegas → el coach la critica → repites. Un agente, y un entrenador para ese agente, en el mismo sitio.

LAB, COACH, PRODUCCION: el bucle de auto-mejora

El salto al torneo

El cash y el torneo no se juegan igual. En un MTT las ciegas suben y tu stack, medido en ciegas grandes, se encoge — y la estrategia tiene que cambiar con la profundidad. System 7 adapta sus rangos por tramos de stack: profundo (juegas póker normal), medio, corto, y muy corto (push/fold: o vas con todo o te tiras, sin medias tintas). En la mesa final, cuando el torneo se reduce a dos jugadores, el motor detecta el heads-up dinámicamente y cambia a un marco consciente de la posición (el botón juega último postflop, c-betea de rango, barrelea). Queda pendiente lo más fino — el ICM (que el valor de una ficha no es lineal cerca de los premios) — pero la base de torneo está.

Lo que nos llevamos

Más allá del póker, el proyecto deja unas cuantas lecciones que aplican a cualquier agente que tome decisiones bajo incertidumbre:

GTO y explotación no son rivales, son capas. El equilibrio es tu suelo; la explotación es tu techo. Pero la explotación solo paga si el de enfrente tiene fugas — y la fuga correcta puede ser la más simple de todas.
El LLM brilla como juicio en los spots difíciles, no como controlador total. Lo barato y determinista resuelve el 95%; el modelo caro y lento se reserva para el 5% que de verdad lo necesita. Y los modelos de razonamiento aportan donde hay muchas variables enredadas.
Medir con honestidad es la mitad del trabajo. Un número ruidoso no es un veredicto. Los intervalos de confianza, la dirección frente al valor absoluto, y la disciplina de no auto-engañarse valen más que cualquier truco de estrategia.
El meta-juego es construir la fábrica. El edge no estuvo en una jugada genial sino en el bucle: autoría → backtest → comparación → despliegue → coaching → repetir. Un agente es tan bueno como la maquinaria que lo itera.

Eso, al final, es de lo que va QuantArmy: agentes para decidir bajo incertidumbre. El póker resultó ser un campo de pruebas perfecto — acotado, medible y despiadado con el autoengaño. Te enseña rápido que tu modelo mental no es la realidad, y que el rival más duro no se gana con más sofisticación, sino con la idea correcta.

Recursos y enlaces

💻 Código (open source): github.com/quantarmyz/system7-poker-arena — el motor heurístico, el híbrido con LLM, el dashboard y todo el tooling.
🃏 La plataforma: dev.fun · el Arena de póker.
🧠 Modelos de razonamiento: DeepSeek · MiniMax.
📖 Parte 2: nos fuimos al heads-up, y el explotador por fin cobró — el diario continúa.

El proyecto sigue vivo en el Arena. Si te interesa el cruce de IA, teoría de juegos y decisión bajo incertidumbre, esto no ha hecho más que empezar.