QUANTARMY (English)

Memetic Wars: how a meme war is orchestrated, measured and shut down

Jesus Cuesta — Wed, 14 Oct 2026 10:00:00 GMT

A diplomat versus a pack of Shiba Inus

June 2022. Mikhail Ulyanov, Russia's permanent representative to the international organisations in Vienna, replies on Twitter to an account whose avatar is a Shiba Inu wearing a military patch. He writes a clumsy line: "You pronounced this nonsense. Not me". Within hours, hundreds of accounts with the same dog, each with its own twist, turn the phrase into a meme and chase it through every one of his replies. Vice ran the story under a blunt headline: the Shiba Inu accounts "chased a Russian diplomat offline".

Those accounts were NAFO, the North Atlantic Fella Organization. It isn't an organisation; it's a swarm. It was born on 24 May 2022 from a drawing that a Pole, Kamil Dyszewski, gave to anyone who donated to the Georgian Legion fighting in Ukraine. By August, Ukraine's Ministry of Defence was thanking it publicly and Defence Minister Reznikov had switched his avatar to a dog. In 2023, Lithuania decorated its founder.

Six years earlier, in a building in St Petersburg, more than eighty people worked on a "translator project" aimed at the United States, inside an operation with a monthly budget of more than 73 million roubles (over $1.25 million). Its signature format was the meme too.

These are two opposite ways of doing the same thing: fighting a war on a front that doesn't appear on any map. This piece is about that front.

The question, in four parts

"Do memes work as weapons?" is too big to answer in one go. We break it into four:

What exactly is memetic warfare, and who has written it down? Doctrine, not folklore.
How is it orchestrated? Which structures, budgets and formats show up in the documented cases.
How do you measure whether it worked? Because volume isn't impact, and that's the main surprise here.
How is it managed and shut down? What the evidence says about detecting, containing, debunking and taking down.

One warning before we start: this is analysis, not a manual. We describe how the documented campaigns were organised and how they are detected and dismantled. We don't explain how to build a deception operation, because that isn't research.

What memetic warfare is

The word meme was coined by Richard Dawkins in The Selfish Gene (1976), in the chapter "Memes: the new replicators". He shortened the Greek mimeme, "imitated thing", so it would rhyme with gene. His examples were tunes, catch-phrases, fashions and ways of building arches: units of culture that get copied, mutate and compete for attention the way genes compete to survive. The internet only changed the speed.

The jump into military writing came early and, at first, from the fringes:

2005–2006. Major Michael B. Prosser of the US Marine Corps proposes, in "Memetics — A Growth Industry in US Military Operations", a Meme Warfare Center with a "Meme Management Officer" advising the commander on meme "generation and transmission".
2010. Lieutenant Brian J. Hancock publishes "Memetic Warfare: The Future of War" in the US Army's Military Intelligence Professional Bulletin.
2011. DARPA launches SMISC (Social Media in Strategic Communication, solicitation dated 14 July 2011): an estimated $42 million of basic research over three years. Its first goal, verbatim: "detect, classify, measure and track the formation, development and spread of ideas and concepts (memes)". Its programme manager, Rand Waltzman, reckons it ended up costing about $50 million over four years.
2016. Jeff Giesea publishes "It's Time to Embrace Memetic Warfare" in the journal of NATO's Strategic Communications Centre of Excellence in Riga: "Trolling, it might be said, is the social media equivalent of guerrilla warfare, and memes are its currency of propaganda". It's an opinion essay, not doctrine. The Centre's website dates it 1 March 2016, though it is often cited as 2015.

The great powers don't write about memes, but they do write about the terrain memes live on:

Russia says informatsionnoye protivoborstvo, "information confrontation", rather than "war". In its Ministry of Defence's Conceptual Views (2011), information war includes "massive brainwashing of the population for destabilizing the society and the state". General Gerasimov's famous article (26 February 2013) says non-military means have "in many cases exceeded the power of force of weapons". Be careful with the label, though. The "Gerasimov doctrine" was coined by analyst Mark Galeotti on his blog on 6 July 2014, and he retracted it himself in Foreign Policy in 2018: "There's one small problem. It doesn't exist".
China set out its "Three Warfares" (public-opinion, psychological and legal warfare) in December 2003, in the People's Liberation Army's political work regulations.
NATO commissioned a study on cognitive warfare in 2020 (François du Cluzel, January 2021) that proposes treating the human as a sixth operational domain. Its most quoted line: "the individual becomes the weapon". NATO itself warns that the study doesn't express its official position, and the formal concept was still awaiting approval in late 2025.
The United States made information the seventh joint function in 2017 and issued dedicated doctrine (JP 3-04) in September 2022, without publishing it. We found no official US doctrinal publication that uses the phrase memetic warfare: memes only appear in research solicitations such as SMISC.

NATO's Centre of Excellence has counted real memes. Its May 2016 report on the Ukraine conflict analysed Facebook and VKontakte from 31 December 2012 to 1 April 2014 and found 348 memes, almost six times as many on VKontakte. The per-network figures the report gives (52 and 289) add up to 341, not 348: a discrepancy in the original.

Figure 1. Fifteen years of memetic warfare. Blue: doctrine and state programmes; ink: operations and movements; grey: responses. Sources: DARPA, Gerasimov (VPK), Brookings, NATO StratCom COE, US v. IRA indictment, UN, Twitter, EU DisinfoLab, Meta and the US Department of Justice.

How it's orchestrated: three documented models

The publicly documented cases fit three models. We call them the factory, the volume cannon and the swarm. They differ in four things: who decides, what it costs, how much it reaches real people and whether it can be attributed.

The factory: the Internet Research Agency

Special Counsel Mueller's indictment of St Petersburg's Internet Research Agency (IRA), dated 16 February 2018, is the best public document on how a meme factory works on the inside:

Budget. By September 2016, "Project Lakhta" exceeded 73 million roubles a month (over $1.25 million), including a million roubles in bonuses. Note that this budget covered the whole project, including Russian and other foreign audiences, not just the US.
Staff. "Hundreds" of employees. By July 2016, more than 80 were assigned to the US-facing "translator project".
Into the streets. The operation went as far as organising real rallies on US soil. The @TEN_GOP account passed 100,000 followers.

New Knowledge's analysis for the Senate Intelligence Committee (December 2018) put numbers on the format. The analysts reviewed about 67,000 Facebook memes and more than 100,000 Instagram memes by hand. Their verdict: "Memes are the propaganda of the digital age". Much of the material was recycled popular memes, and the most visual network delivered the most:

Figure 2. Instagram, the image network, delivered more than twice Facebook's engagement. Source: New Knowledge, "The Tactics & Tropes of the Internet Research Agency" (17 Dec 2018), based on data supplied by the platforms themselves.

The most-quoted reach figure, that 126 million Facebook users "may have been served" IRA content, is the company's own (Colin Stretch before the Senate, 31 October 2017). The direct figure was 29 million. Twitter identified 3,841 accounts linked to the IRA. The Senate report (volume 2, October 2019) highlights something else: the most targeted group was African-Americans, and the fake Blacktivist page racked up 11.2 million engagements. After election day, IRA activity rose, by 238% on Instagram.

The factory 2.0: Doppelganger

In September 2022, EU DisinfoLab and Qurium documented Doppelganger: clones of at least 17 European media outlets (Bild, The Guardian, 20 Minutes, Ansa…) on look-alike domains, pushed with Facebook Pages and fake profiles. Two years later, on 4 September 2024, the US Department of Justice seized 32 domains. It attributed the operation to the firms Social Design Agency and Structura, working under Russia's Presidential Administration.

The FBI affidavit is explicit about the role of memes. Its "Good Old U.S.A. Project" planned "mass distribution of text comments and memes in Facebook and X discussion threads", with messages for six swing states. One planning document set a target of 60,000 comments a month for France and Germany, and the agency kept a list of more than 2,800 influencers in 81 countries. The factory no longer manufactures only content. It manufactures conversation around the content.

The volume cannon: Spamouflage

The Chinese operation known as Spamouflage (Dragonbridge at Google) is the perfect counter-example. In August 2023, Meta removed 7,704 Facebook accounts, 954 Pages, 15 Groups and 15 Instagram accounts, with a presence on more than 50 platforms. Ben Nimmo, then Meta's head of threat intelligence, called it "the largest, though unsuccessful, and most prolific covert influence operation that we know of".

Note the word unsuccessful. Meta found no "substantial engagement among authentic communities". Google, which chases it on YouTube, gives starker numbers. Of the more than 57,000 channels it disabled in 2023, 80% had zero subscribers. Of the more than 900,000 videos removed, 65% had fewer than 100 views and 30% had none. It's a cannon firing into a desert.

The swarm: NAFO, Saint Javelin and the Ghost of Kyiv

The third model has no headquarters and no budget. NAFO is a decentralised network with a shared look (the "fella" dog), a clear goal (ridiculing Kremlin propaganda) and a funding route: the avatars were rewards for donors. Its founder estimates they raised "more than $1 million", although nobody keeps an official tally. Saint Javelin, a Toronto sticker shop selling a Madonna holding a missile launcher, started on 16 February 2022 aiming to raise $30,000. By September 2025 it said it had passed $2.5 million. Both figures come from the organisers themselves.

The swarm also manufactures myths. The Ghost of Kyiv, a pilot said to have downed dozens of Russian jets in the first days of the invasion, spread across every network. On 30 April 2022, Ukraine's own Air Force called it "a superhero legend created by the Ukrainians", a collective symbol of its pilots. It worked for morale and for fundraising. Technically, it was also friendly disinformation.

The three models in one table

Model	Case	Who decides	Documented scale	Authentic reach	Attribution
Factory	IRA (2014–2018)	Hierarchy with a budget	>80 people on the US; >$1.25M/month	High: 187M engagements on Instagram	Criminal indictment, 2018
Factory 2.0	Doppelganger (2022–2024)	Contractors of the Presidential Administration	17 cloned outlets; plan for 60,000 comments/month	Low, according to the platforms	32 domains seized, 2024
Volume cannon	Spamouflage (2019–)	Linked to Chinese law enforcement (Meta)	7,704 FB accounts; >175,000 disruptions at Google	Near zero: 80% of channels with no subscribers	Platform attribution
Swarm	NAFO (2022–)	Nobody: coordination through a look and a goal	>$1M, self-reported	High in its niche; never rigorously measured	Public and proud

The table's lesson is awkward for anyone who thinks in budgets: volume doesn't buy reach. The factory that worked did so because it exploited real fractures (race, identity) in the right format (images, Instagram). The biggest cannon we know of had almost no audience.

When the platform is the weapon: Myanmar

In one case nobody needed a factory. The UN Fact-Finding Mission on Myanmar (report A/HRC/39/64, September 2018) wrote that Facebook "has been a useful instrument for those seeking to spread hate, in a context where for most users Facebook is the Internet", and that the company's response had been "slow and ineffective". Nearly 725,000 Rohingya fled the country after August 2017. The report Facebook itself commissioned from BSR (November 2018) admitted it: "we weren't doing enough". Sometimes the parallel front isn't opened by an army but by an unmoderated ecosystem.

And the caliphate: ISIS on Twitter

Before anyone else, the Islamic State understood the network as a front. Berger and Morgan's census for Brookings (March 2015) counted at least 46,000 supporter accounts between September and December 2014, with an upper bound of about 70,000. Each had about a thousand followers on average, and a core of 500 to 2,000 hyperactive accounts drove most of the reach. Three in four wrote in Arabic.

Why they spread

Why the IRA's factory delivered and the Chinese cannon didn't comes down to three solid findings in the literature.

Falsehood travels further, and not because of bots. Vosoughi, Roy and Aral analysed in Science (2018) some 126,000 stories spread by about 3 million people on Twitter between 2006 and 2017. Falsehoods were 70% more likely to be retweeted than the truth. It took the truth about six times as long to reach 1,500 people. The key point is that bots accelerated true and false news at the same rate: falsehood spreads further "because humans, not robots, are more likely to spread it". The authors point to novelty, and to the surprise or disgust it provokes.

Moral emotion is fuel. Brady and colleagues (PNAS, 2017) studied 563,312 messages on polarised issues. Each additional moral-emotional word increased a message's diffusion by about 20%, and the effect was stronger within each ideological bubble than between them. A well-made war meme is exactly that: moral outrage compressed into an image.

Memes are born on the fringes and then jump. Zannettou and colleagues (IMC 2018) tracked about 160 million images across Twitter, Reddit, 4chan's /pol/ and Gab over thirteen months in 2016–2017. They used perceptual hashing, a 64-bit fingerprint that survives crops and edits. /pol/ was the biggest meme factory (1.57 million posts), but The_Donald was the most efficient community at pushing memes out to the rest. The seeding happens in small, radical niches; the harvest, on the big platforms.

How impact is measured

If volume isn't impact, you need another yardstick. The one analysts and platforms use most is Ben Nimmo's Breakout Scale (Brookings, September 2020). It doesn't count how many messages are posted. It measures how far a campaign breaks out of its niche:

Figure 3. Ben Nimmo's Breakout Scale. Each step means escaping one more audience: a community, a platform, social media and, finally, the screen. Source: Brookings, September 2020.

By this yardstick, the big fear of recent years, generative AI, stays in proportion for now. In May 2024, OpenAI disclosed five operations that used its models: Bad Grammar and Doppelganger (Russia), Spamouflage (China), IUVM (Iran) and Zero Zeno, run by a commercial firm in Israel. None scored above Category 2: "no breakout to authentic audiences". By October 2025 the running total had passed 40 networks disrupted since February 2024. Its conclusion: actors bolt AI onto workflows they already had rather than invent new ones. Microsoft (April 2024) points the same way: AI-enhanced content is more influential than fully AI-generated content, and fake audio more than fake video.

A methodological caveat: these "limited impact" assessments come from the platforms themselves, about what they find. What they don't find never makes the statistics.

How it's detected

Platforms don't take these networks down for what they say, but for how they behave. Meta calls it Coordinated Inauthentic Behavior (CIB): "coordinated efforts to manipulate public debate for a strategic goal, in which fake accounts are central to the operation". It has published its takedowns since 2017. By December 2022 it had removed more than 200 networks from 68 countries, and the ranking of origins is stable: Russia (39 networks by August 2024), Iran (about 30) and China (11).

The reference academic method is Pacheco and colleagues' (ICWSM 2021). You pick a behavioural trace, build an account-to-trace network and project it onto the accounts: two accounts are linked if they share too many traces. Finally, an analyst reviews the groups by hand. Its strength is that it detects coordination, not automation, so it catches human-run operations that a bot detector misses. Those detectors fail a lot, by the way: Rauchfleisch and Kaiser (PLOS ONE, 2020) showed that Botometer labels many humans as bots and vice versa, especially outside English.

For memes, the natural trace is the image's perceptual hash, the same one Zannettou and colleagues used. This is the core of the method in dependency-free Python with synthetic data: 60 organic accounts post random memes over a week, and a network of 6 accounts posts five waves of the same meme within 40 seconds.

python

"""Detecting coordinated behaviour through co-posting (synthetic data, standard library only).

Idea (Pacheco et al., ICWSM 2021): two accounts that post the same content, again and again,
seconds apart, rarely do so by chance. Count how often each pair coincides within a window,
keep the pairs above a threshold and group them.
"""
import random
from collections import defaultdict

random.seed(7)
WINDOW = 60     # seconds: two posts of the same meme closer than this "coincide"
THRESHOLD = 3   # minimum coincidences to call a pair of accounts coordinated

# --- Synthetic data: (account, perceptual hash of the meme, second it was posted) ---
events = []
memes = [f"meme_{i:02d}" for i in range(30)]
for c in range(60):                                   # 60 organic accounts
    for _ in range(random.randint(3, 12)):
        events.append((f"user_{c:02d}", random.choice(memes), random.randint(0, 7 * 86400)))
network = [f"net_{c}" for c in range(6)]              # 6 accounts in a coordinated network
for wave, meme in enumerate(["meme_03", "meme_11", "meme_17", "meme_22", "meme_29"]):
    t0 = 86400 * (wave + 1)
    for account in network:
        events.append((account, meme, t0 + random.randint(0, 40)))   # all within 40 s

# --- 1. Coincidences per pair: same meme inside the window ---
by_meme = defaultdict(list)
for account, meme, t in events:
    by_meme[meme].append((t, account))
pairs = defaultdict(int)
for meme, posts in by_meme.items():
    posts.sort()
    for i, (t1, a) in enumerate(posts):
        for t2, b in posts[i + 1:]:
            if t2 - t1 > WINDOW:
                break
            if a != b:
                pairs[tuple(sorted((a, b)))] += 1

# --- 2. Pairs above the threshold → groups (union-find) ---
parent = {}
def root(x):
    parent.setdefault(x, x)
    while parent[x] != x:
        parent[x] = parent[parent[x]]
        x = parent[x]
    return x
for (a, b), n in pairs.items():
    if n >= THRESHOLD:
        parent[root(a)] = root(b)
groups = defaultdict(set)
for account in parent:
    groups[root(account)].add(account)

print(f"events: {len(events)} · accounts: {len({e[0] for e in events})} · pairs that ever coincide: {len(pairs)}")
print(f"pairs with >= {THRESHOLD} coincidences within {WINDOW} s: {sum(1 for n in pairs.values() if n >= THRESHOLD)}")
for g in sorted(groups.values(), key=len, reverse=True):
    print(f"coordinated group ({len(g)} accounts): {', '.join(sorted(g))}")

Expected output:

text

events: 497 · accounts: 66 · pairs that ever coincide: 17
pairs with >= 3 coincidences within 60 s: 15
coordinated group (6 accounts): net_0, net_1, net_2, net_3, net_4, net_5

Of 17 pairs that ever coincide, only 15 do so three times or more, and they are exactly the 15 possible pairs among the network's 6 accounts. Chance coincidences between organic users stay below the threshold. Real data is never this clean: you have to calibrate the window and threshold, down-weight very popular memes (which coincide through sheer virality) and review every group by hand before calling it a network. But this is the logic behind platform takedowns: the content can be legitimate; the choreography can't.

How it's managed and shut down

Detecting isn't responding. On the available evidence, the response takes the shape of a loop, and the first decision is the most counter-intuitive:

Figure 4. The response loop. If a campaign hasn't left its niche (Category 1–2), debunking it in public may be exactly what breaks it out. Our own diagram, based on the Breakout Scale (Nimmo, 2020) and the evidence cited in this section.

Before: inoculate

Psychological inoculation, or prebunking, teaches the manipulation technique before the specific message arrives. Roozenbeek, van der Linden and colleagues (Science Advances, 2022) tested it in the lab and on YouTube. In the field, 5.4 million US users saw the ads and 22,632 answered a test question. Recognition of techniques such as scapegoating and false dichotomies improved by about 5%. That's little per person but a lot at scale, since it costs the price of an ad.

Google Jigsaw took the idea to Poland, Czechia and Slovakia in autumn 2022, against hoaxes about Ukrainian refugees. Its videos passed 38 million views, but the effect was uneven: largest in Poland, mixed in Czechia and close to zero in Slovakia, where the videos were dubbed rather than produced locally. The vaccine works best with a local accent.

During: answer fast, and with wit

Taiwan turned this into state policy under the motto "humor over rumor". In February 2020 the Premier answered a hoax that was causing panic-buying of toilet paper with a meme. The operating rule attributed to the government, the "2-2-2", exists in several public versions: 20 minutes or 2 hours to respond, 200 words and 2 images. We found no official document fixing the exact version. What stays constant is the idea: speed, brevity and an image, the same weapons as the meme being answered.

Debunking doesn't backfire. The feared "backfire effect" (a correction that strengthens the false belief) is rare. Wood and Porter (Political Behavior, 2019) ran 5 experiments with more than 10,100 people on 52 issues: no correction produced a backfire.

Context notes work, but they arrive late. X's Community Notes are the largest natural experiment. On the specific post the effect is strong; across the platform it's modest, because the note appears after the viral moment has passed:

Figure 5. The effect of a context note from the moment it appears versus over the post's whole life. Sources: Slaughter, Peytavin, Ugander and Saveski (PNAS, September 2025; 40,078 posts) and Chuai et al. (Nature Communications, accepted 2026; 237,180 cascades).

After: take down, and watch where they go

Network takedowns (CIB) are the platforms' bluntest tool and the one that leaves the clearest public record. In 2018 Twitter opened an archive of state-backed operations with the IRA's 3,841 accounts and 770 from Iran. By 2019 it held more than 30 million tweets.

Removing people (deplatforming) has stronger evidence behind it than is often assumed, with one caveat:

McCabe and colleagues (Nature, 2024) studied the removal of 70,000 misinformation-spreading accounts after 6 January 2021, using a panel of more than 500,000 users. Misinformation circulation fell, both from the banned accounts and from their followers. The authors can't isolate the exact size of the effect, because it coincided with the storming of the Capitol.
Jhaver and colleagues (2021) measured, across 49 million tweets, the removal of Alex Jones, Milo Yiannopoulos and Owen Benjamin: conversation about them dropped sharply, and so did their supporters' toxicity.
The caveat: those who migrate to a platform of their own lose audience but can radicalise. Horta Ribeiro and colleagues (2021) saw it with r/The_Donald.

Above it all: rules and the state

The European Union. Since 25 August 2023, the Digital Services Act has required the largest platforms to assess and mitigate systemic risks to civic discourse. Its first formal proceedings were opened against X on 18 December 2023, after the wave of disinformation about the Israel–Hamas war; the maximum fine is 6% of global turnover. The Code of Practice on Disinformation became a code of conduct under the Act on 1 July 2025.
Measured attacks. The EUvsDisinfo database holds more than 18,000 cases. The European External Action Service's reports on foreign manipulation counted 100 incidents in 2022 (Russia in 88), 750 in 2023 and 505 in 2024.
Sanctions. The EU suspended RT and Sputnik on 1 March 2022. The US paired the Doppelganger domain seizures with sanctions on 10 individuals and 2 entities the same day.
And defences get switched off too. The State Department's Global Engagement Center, the US office for countering foreign propaganda, closed on 23 December 2024. Its successor, R/FIMI, was shut on 16 April 2025. Shutting down a memetic war also depends on someone still being willing to fight it.

And counter-messaging in uniform

The British Army has a unit for this, the 77th Brigade, which describes itself as a hybrid unit to "combat new forms of warfare in the information environment". Freedom of Information requests revealed that it monitored disinformation trends on UK social media during COVID. It's a reminder that defensive tools can also point inwards.

Method note: what this is and what it isn't

It is a synthesis of primary sources: court documents, platform reports, parliamentary and UN reports, and peer-reviewed papers. Every figure comes with its source.
It isn't our own measurement of impact. Most reach figures come from the platforms themselves (Meta, Google, Twitter/X, OpenAI), and the independent analyses, such as New Knowledge's, worked on data those same platforms supplied. What they don't detect doesn't show up.
It isn't a manual. We describe how the documented campaigns were organised and how they are detected. We give no instructions for creating fake profiles or evading detection.
Some figures are self-reported and we couldn't audit them (what NAFO and Saint Javelin raised), and some rules have no official document (Taiwan's "2-2-2"). We say so where they appear.
The code is a teaching example with synthetic data, not a production-ready detector.

What we take away

Volume doesn't buy reach. The biggest operation we know of, Spamouflage, barely had an audience. The one that worked, the IRA, exploited real fractures in the right format. Measure breakout (Categories 1–6), not messages.
People push memes, not bots. Falsehood travels 70% further on novelty and moral emotion, and bots don't change that. Defence has to speak to people.
You detect the choreography, not the opinion. Takedowns that hold up are based on coordinated behaviour, not on content. That's what makes them defensible in a democracy.
Speed decides the shutdown. Inoculate early (prebunking), answer fast and with wit, annotate early and take the network down. A note that arrives late cuts 46% of what's left, but only 12% of the total.

Sources and links

Doctrine and history

Dawkins, R. (1976). The Selfish Gene, ch. 11, "Memes: the new replicators". Oxford University Press.
Hancock, B. J. (2010). "Memetic Warfare: The Future of War". Military Intelligence Professional Bulletin 36(2). irp.fas.org
DARPA (2011). Social Media in Strategic Communication (DARPA-BAA-11-64). darpa.mil
Giesea, J. (2016). "It's Time to Embrace Memetic Warfare". Defence Strategic Communications 1. NATO StratCom COE. stratcomcoe.org
Galeotti, M. (2018). "I'm Sorry for Creating the 'Gerasimov Doctrine'". Foreign Policy. foreignpolicy.com
Russian Ministry of Defence (2011). Conceptual Views Regarding the Activities of the Armed Forces of the Russian Federation in the Information Space. nsarchive.gwu.edu
du Cluzel, F. (2021). Cognitive Warfare. NATO ACT Innovation Hub. innovationhub-act.org
NATO StratCom COE (2016). Framing of the Ukraine–Russia Conflict in Online and Social Media. stratcomcoe.org

Cases

United States v. Internet Research Agency et al. (2018), indictment. justice.gov
New Knowledge (2018). The Tactics & Tropes of the Internet Research Agency. law.shu.edu
EU DisinfoLab and Qurium (2022). Doppelganger. nsarchive.gwu.edu
US Department of Justice (2024). Doppelganger affidavit. justice.gov
Google TAG (2024). Dragonbridge. blog.google
Independent International Fact-Finding Mission on Myanmar (2018). A/HRC/39/64. ecoi.net
Berger, J. M. and Morgan, J. (2015). The ISIS Twitter Census. Brookings. brookings.edu
Kyiv Post (2023). Interview with NAFO's founder. kyivpost.com

Mechanics, measurement and detection

Vosoughi, S., Roy, D. and Aral, S. (2018). "The spread of true and false news online". Science 359(6380). doi:10.1126/science.aap9559
Brady, W. J. et al. (2017). "Emotion shapes the diffusion of moralized content in social networks". PNAS 114(28). doi:10.1073/pnas.1618923114
Zannettou, S. et al. (2018). "On the Origins of Memes by Means of Fringe Web Communities". IMC. arxiv.org
Nimmo, B. (2020). "The Breakout Scale". Brookings. brookings.edu
Pacheco, D. et al. (2021). "Uncovering Coordinated Networks on Social Media". ICWSM. ojs.aaai.org
Rauchfleisch, A. and Kaiser, J. (2020). "The False Positive Problem of Automatic Bot Detection in Social Science Research". PLOS ONE. doi:10.1371/journal.pone.0241045
OpenAI (2024). AI and Covert Influence Operations: Latest Trends. openai.com
DISARM Foundation. An open framework for describing influence operations. disarm.foundation

Response

Roozenbeek, J. et al. (2022). "Psychological inoculation improves resilience against misinformation on social media". Science Advances. cam.ac.uk
Wood, T. and Porter, E. (2019). "The Elusive Backfire Effect". Political Behavior 41. doi:10.1007/s11109-018-9443-y
Slaughter, I. et al. (2025). The effect of Community Notes. PNAS. pmc.ncbi.nlm.nih.gov
McCabe, S. D. et al. (2024). "Post-January 6th deplatforming reduced the reach of misinformation on Twitter". Nature 630. doi:10.1038/s41586-024-07524-8
Jhaver, S. et al. (2021). "Evaluating the Effectiveness of Deplatforming as a Moderation Strategy on Twitter". Proc. ACM HCI. doi:10.1145/3479525
European Commission. Code of Practice on Disinformation. digital-strategy.ec.europa.eu
EEAS (2024). 2nd EEAS Report on Foreign Information Manipulation and Interference Threats. eeas.europa.eu

Selling Vol Isn't Free Money: The 3 Numbers That Matter

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

The Tuesday vol didn't revert

It's a Tuesday morning. You pull up the terminal, check the name you've been watching for weeks, and its 30-day implied vol is printing 48, sitting right at the top of its yearly range.

Vol is mean-reverting. Everyone knows that. So you do the obvious thing: you sell the straddle. Maybe, if you're prudent, an iron condor.

Two days later, implied prints 61. Your short is deep underwater, and the reversion you were promised is nowhere to be found. The position eventually comes back — mostly — after a week of not sleeping.

What went wrong? Actually, nothing. You were right that vol mean-reverts. But you were staring at the trees while ignoring the forest: a single implied vol number, on its own, tells you almost nothing about whether you should be selling it, buying it, or staying away.

To actually trade the reversion you need three things you can't read off that one print. Getting all three is what separates collecting premium from donating it. This piece is a full investigation of those three numbers — IV/HV Premium, IV Rank and Vol-of-Vol — with the formulas, the figures from the original Quant Galore × Alphanume Research study, an independent validation on real VIX data, and the code to reproduce everything.

Reversion is real, but it isn't free

Mean reversion in implied vol is one of the most reliable regularities in all of markets: vol spikes on fear, then bleeds back as the fear fades. It's so dependable that the entire short-vol complex — every iron condor seller, every FinTwit overwriter — is at root the same bet: today's elevated vol will be lower tomorrow.

Mathematically, the intuition anchors nicely in an Ornstein-Uhlenbeck process. If volatility $\sigma_t$ followed one:

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

where $\theta$ is the long-run level, $\kappa$ the speed of reversion and $\xi$ the volatility of volatility itself (keep that $\xi$ in mind — it will return). The half-life of a shock — how long until half of it dissipates — is:

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

And there's the first problem: the model that justifies your trade has two parameters you're not looking at. A high $\kappa$ hands your vol back in days; a low $\kappa$ leaves you swimming against the current for weeks. And a high $\xi$ turns the wait into a knife fight. "Vol mean-reverts" without $\kappa$ and $\xi$ is a slogan, not a trade.

The second problem is reference. The instinct says: see high vol, sell it; see low vol, buy it; collect the difference. But high compared to what? A 48 vol for a sleepy regional utility is a five-alarm fire. For a small biotech walking into a data readout, it's cheap. The number means nothing until you anchor it to something, and "I have a feeling this is elevated" is not the anchor professionals use.

The right question splits into three:

Is vol actually expensive? Are you being paid to sell it, relative to what the stock is really doing?
Is it expensive for this specific name? Stretched far up in its own trailing range, or just normal-for-it?
How stable is vol itself? Does the reversion come back as a gentle drift or a knife fight?

Three questions, three numbers. Let's take them one at a time.

Expensive compared to what? The volatility risk premium

The first meaning of "expensive vol" is expensive relative to realized. That's the classical volatility risk premium (VRP): the gap between what options are pricing (implied vol) and what the stock is actually delivering (realized vol).

Realized vol is estimated from price history. The simplest estimator is 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}}

and a statistically more efficient version is the Parkinson estimator, which uses each session's high-low range:

\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}

With both in hand, the VRP is expressed as a spread $s_t = IV_t - HV_t$ or, cleaner and comparable across names, as a ratio:

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

When 30-day implied sits above 30-day realized, $\rho > 1$ and you're being paid more in premium than the stock has been moving. That's the crux of the IV/HV Premium feed: per name, per day, implied vs realized as both a spread and a ratio, ranked across the whole universe.

And why should that gap pay you at all? Because there's a direct theoretical link between the gap and expected P&L. For a delta-hedged short straddle, the accounting per unit of time is, to first order:

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

Note the detail almost nobody mentions: the expected edge is proportional to the difference of variances, not vols. It grows with the square of the gap: a ratio of 1.5 is not 50% more edge than 1.0 — it's $(1.5^2 - 1) = 1.25$ units of variance versus $(1.1^2 - 1) = 0.21$ . Almost six times as much. That's why the "richness" filter isn't cosmetic: it's the difference between trading with a tailwind and rowing upstream.

The data confirms it with uncomfortable clarity. Lining up forward reversion by IV/HV ratio bucket, selling vol where the ratio is below 1 bled — the cheap names kept drifting higher. The seller's edge only switches on above 1.0, and at the richest end, around 1.5×, the short captured roughly 7 vol points of reversion:

The seller's edge is a switch, not a dial: off below 1.0, and bigger the wider the implied-realized gap. Figures from the Alphanume study.

Expensive for this name? IV Rank

The second meaning is expensive relative to its own history. A 48 vol living in the 95th percentile of a name's trailing range is a very different animal from a 48 vol that's been the floor all year. The tool is IV Rank: today's implied (and realized) dropped into the name's own trailing 52-week band, as a 0-to-100 rank:

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

Don't confuse it with IV Percentile, which counts the fraction of days spent below the current level:

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

Rank tells you where you sit inside the range; percentile tells you how much time was spent below. After a single violent spike, rank can print 95 while percentile sits at 60. For hunting extreme stretches, rank is the more sensitive instrument.

And reversion, measured from the rank, is brutally clean. The study bucketed every stock in the universe by its IV rank and looked at what its 30-day implied did over the following month. The pattern is about as clean as anything you'll see in markets:

Reversion by IV-Rank decile, optionable universe (Alphanume study): names entering the top decile of their own range saw implied vol fall ~-18% over the next month; names in the bottom decile saw it climb ~+32%. Nearly linear the whole way down.

The higher the rank, the harder the reversion pulls. This is the signal under everyone's intuition, made measurable.

Stacking the edge: the full screen

Put the two legs together and the hunch becomes a robust screen. The flagship version is the conditioned premium sell, and it runs in five steps:

The funnel: full universe → rich only (ratio ≥ 1.25) → stretched only (IV rank ≥ 70) → structure sized to the implied range → harvest. Counts illustrative.

Universe: the day's IV/HV Premium feed, settled rows only (only_final=true), so you're not trading off a provisional intraday print.
Richness: filter to the top of the IV/HV ratio distribution (min_ratio_rank=1.25 or higher). This is the "am I actually being paid" gate.
Stretch: join in IV Rank and keep only names high in their own trailing band (min_iv_rank=70). This is the "is reversion likely" arm.
Structure: the short as a strangle or iron condor around the at-the-money implied range, sized to the move the chain is implying — not to your conviction. A straddle's breakevens are $BE_{\pm} = K \pm (C + P)$ ; the structure must respect them, not your enthusiasm.
Harvest: let the reversion work over the following weeks, as rich, stretched vol does what rich, stretched vol does.

The difference between running this screen and just selling whatever looks high isn't theoretical. Measuring the vol points captured shorting 30-day vol and holding a month, sliced by how you screen:

The ladder: selling everything indiscriminately captures ~0 — a pure coin-flip. Filter to rich names: +4.6 points. Stack the high-IV-rank condition on top: +12.5, roughly triple. Each filter is a number from one of the feeds, and each one stacks.

This is the whole pitch, honestly. The general mechanism of selling high implied vol was never a secret or proprietary. What you couldn't do without the data is condition the trade tightly enough to be on the right side of it.

Vol-of-Vol: the third number

One question remains that the first two can't answer: once you're in, how violent is the ride?

That's Vol-of-Vol — the $\xi$ from the OU process we opened with. It measures the instability of a name's vol itself, e.g. as the standard deviation of daily implied-vol changes over the trailing window:

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

A low reading: vol is well-behaved and grinds around a level. A high reading: vol is whipping around, lurching between regimes. Same short (rich + high rank), split by vol-of-vol:

Same strategy, two temperaments. Steady-vol names: a tight distribution clustered around a modest win, ~83% hit rate. Unstable-vol names: more captured on average, winning more often (>90%), but a much wider, wilder spread of outcomes, stretched out to the right.

Vol-of-vol is, in practice, a sizing dial that tells you what kind of trade you're signing up for:

Low VoV → steady, theta-like income. Smaller reversions, but you can size them up and sleep through them.
High VoV → this is where the big snapbacks live, because the vol got violently stretched to begin with. They pay more and hit more often, but they'll also hand you a stomach-churning week or two before they resolve. Size those down.

There's more than shorting vol: the long side

When trading vol comes up, the conversation almost always skews to selling and collecting premium. But flip every sign and the same machinery points you at vol to buy.

When a name sits in the bottom decile of its IV rank, the same reversion math says its implied rises ~+32% over the following month. That's the classic long-gamma setup: vol cheap relative to its own history, with the pull upward more often than not.

The pluckier version pairs IV rank against HV rank: when implied is scraping the bottom of its range while realized is already starting to creep up above it, you're looking at a name whose options are priced for a calm the stock has quietly stopped delivering. Long the straddle — or whatever gives you the cleanest gamma — and let the implied catch up to the realized that's already moving:

The mirror trade. Left: the bottom decile of rank is where cheap vol drifts up. Right: the buyer's dream setup — implied on the floor, realized already creeping above it.

Independent validation on real data

The study's numbers come from a proprietary feed (Alphanume). Does the pattern reproduce with public data? We checked with the CBOE's official VIX series — 2,711 observations between 2015 and 2026 — applying the exact same mechanics: 252-day rank of VIX, deciles, and forward 21-day change:

Our own replication on VIX (official CBOE data, 2015–2026): same shape as the single-name study. The top rank decile loses -13.7% on average over the next month — with 77.9% of those observations negative —; the bottom decile gains +11.7%, with 72.8% positive. Nearly monotone the whole way.

The structure is the same as in the single-stock universe: the more stretched the fear gauge is inside its own range, the harder reversion pulls. Different instrument, different data source, same law.

A note on method: what this is and what it isn't

These are real data pulls, not a turnkey backtest. The reversion being measured is a mark-to-market on the vol itself over a one-month forward window. The realized path and execution costs are live risks that sit on top of the vol move — and the vol-of-vol section is exactly about respecting the first of those.

In plain Greek: even if implied falls as the rank predicts, a short straddle can still lose money if the stock moves more than the vol drop compensates. The P&L equation doesn't lie:

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

and $\sigma_r$ is a realization, not a promise. The point of this investigation is the proper filtering, and the demonstration that these three numbers move the odds in a measurable, stackable way. What you build on top of that is the fun part.

Conclusion: three questions, three numbers

Everyone already knows vol mean-reverts. That knowledge, on its own, is worth almost nothing — which is why so many people sell "high" vol and still manage to lose.

The edge is knowing, before you commit a dollar:

Question	Number	Study threshold
Am I actually being paid?	IV/HV Premium — ratio $\rho = IV/HV$	$\rho \gtrsim 1.25$ (edge dies below 1.0)
Is it stretched in its own range?	IV Rank (0–100, 52 weeks)	$\geq 70$ (D10 reverts ~-18%/month)
How rough is the ride?	Vol-of-Vol — $\operatorname{sd}_{21}(\Delta IV)$	a sizing dial, not an entry signal

If you've ever sold a straddle on a feeling and watched it gap against you, you already know exactly what these three numbers are worth.

This article expands the study "A Common Sense Guide to Volatility Trading" by Quant Galore × Alphanume Research (June 2026). The decile, ratio and filter figures are the ones they reported, redrawn in our style; the VIX validation is our own computation on official CBOE data. None of this is investment advice.

Code: full replication

The original study publishes its scripts in the Strategy Lab on GitHub (folder Stock Volatility Trading) using the Alphanume API. Here's our self-contained version, on 100% public data, which reproduces the VIX validation chart above and sets up the full toolbox (close-to-close HV, Parkinson, IV Rank, Vol-of-Vol) to apply to any name:

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

Expected output (the numbers from the validation chart):

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 %

To take it to individual stocks you only need a source of 30-day implied vol per name (your broker's, ORATS, or the Alphanume API with a free key) crossed with daily OHLC: hv_close_to_close gives you realized, iv_rank the stretch, vol_of_vol the temperament. The full screen is literally three lines of pandas over those columns — the rest is discipline.

Want to go deeper on rigorously measuring and budgeting tail risk inside a systematic flow? The open course QAO — Quantitative risk: VaR and Expected Shortfall covers the full framework with real code.

System 7 (part 2): we went heads-up, and the exploiter finally got paid

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

In part 1 we ended on an uncomfortable lesson: we built an elaborate exploitative engine — hand classification, math filters, node-locking, an LLM for the hard nodes — and it lost. Against the reference panel, pure heuristic node-locking ran −9.75 bb/100 and the LLM hybrid −1.66 bb/100. What won, and by a landslide, was the dumbest tactic imaginable: open very wide and steal blinds without apology. +119 bb/100 with a strategy that fits on a napkin.

The moral of that piece was that the engine beats the brilliant idea: the edge isn't in the genius play, it's in the loop of author → test → compare → deploy → coach → repeat. And that exploitation only pays when there's a real leak to exploit.

What we didn't tell you — because it hadn't happened yet — is what that engine does when you finally give it a real opponent to aim at. This is that story. Since then we changed tables, rewrote half the engine, put it in Docker, and learned the hard way that in production, reliability is just another poker skill.

Recap: where we left off

For newcomers: System 7 is a No-Limit Hold'em agent that plays in the Arena on dev.fun, a tournament where software agents face each other (and humans). The core is deterministic Python — fast, reproducible, testable — with an LLM "brain" (MiniMax M3) we only call for the hard nodes. It's all open on GitHub.

Part 1 was played at 6-max tables. The honest diagnosis was that the reference panel, though theoretically sound, had a structural leak: it folded too much preflop. Our microscope of a machine wasn't needed; a hammer would do. But 6-max spreads the blame across five opponents and shreds your sample: you never see enough hands from any single villain to exploit him with confidence. The microscope had no one to focus on.

So we did the obvious thing we hadn't done: we took four players off the table.

The pivot to heads-up (Season S4)

Heads-up — one on one — changes everything, and not out of romance. It changes it through statistics. At 6-max, 500 hands are ~80 hands of each opponent: noise. Heads-up, 500 hands are 500 hands of the same opponent. At last the sample grows fast enough that "this guy folds too much to the 3-bet" goes from a hunch to a number with a confidence interval.

6-max: ~80 hands/opponent. Heads-up: ~500 of the same opponent

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

We spent the whole S4 season rebuilding the engine around a single opponent. In repo terms this was v0.6.0: node-locking activation, all-in EV, a heads-up-specific coach, and a unified panel. But the one-line summary hides the mindset shift: we stopped asking "what's the correct play against the field?" and started asking "what's the correct play against this guy I've been watching for 1,500 hands?".

It's exactly part 1's thesis — exploit instead of playing equilibrium — but finally with the terrain in our favor.

Node-locking that finally pays

Node-locking, as a reminder, means pinning (locking) part of the opponent's strategy based on what you've observed, and recomputing your best response against that specific leak. In part 1 it was, in practice, an expensive ornament: the sample wasn't big enough to trust the lock.

Heads-up, it is. We calibrated the adaptation threshold to ~1,900 hands per opponent, which is the order of magnitude the Arena deals in a serious session. Below that, we play a solid base and don't invent reads. Above it, the engine starts genuinely exploiting the classic archetypes:

NIT — plays only premiums: we steal his blinds relentlessly and pay him off almost nothing when he finally wakes up.
STATION — calls everything: we stop bluffing and fatten the value. Here a bluff is literally setting money on fire.
LAG — the loose-aggressive: we give the aggression back where the math holds and set traps at the nodes.
MANIAC — the extreme version: patience, traps, and letting him crash into himself.

Two fine-tunes came with this that sound minor and matter a lot. First, we widened the button c-bet range to coordinated boards: heads-up, initiative is valuable, and giving up too much turns you into the very NIT you want to exploit. Second, we fixed a leak of our own we'd been dragging along: underpairs on paired boards (an underpair against, say, KK on board) stopped being treated as commit-level hands and got reclassified as what they are — bluff-catchers. It's a small correction to a hand-classification table, and bb/100 live and die on exactly those.

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

All the tuning lives in system7-hu.json: open sizes, barrel frequencies, bluff 3-bets, and small-blind ranges. Strategy as data, versioned, swappable with an environment variable. That design — we promised it in part 1 — is what makes iteration cheap.

Motor v1.5: the survival logic

And here we reach today. v0.7.0, shipped this very afternoon, brings what we internally call motor v1.5, "survival." It's the biggest conceptual change since part 1, and it's born of an ugly observation: an engine optimized to maximize EV on every hand makes decisions that are great for the long run and ruinous for staying at the table.

The canonical example is AKo. Against a single opponent, getting it in with AKo is usually fine. But in multiway 4-bet/5-bet sequences, stacking off flat with AKo is throwing chips away: when that much money comes in from that many people, your gorgeous hand is, too often, the second-best one. Motor v1.5 stops doing that.

The new piece is commitment tiers — shallow / deep / all-in — indexed by re-raise depth. Instead of a uniform "with this strength, go with it all" rule, commitment is graduated by tier: the hotter the re-raise war gets, the more selective the hand you'll accept stacking off with. In multiway, paired hands also stop auto-committing at low SPR. Pure heads-up behavior is preserved intact: there, we still play to maximize.

Two engineering details that matter more than they look. All of this is behind a flag, survival:true: by default the behavior is unchanged, so nobody gets surprised and we can A/B against the previous engine. And it shipped with 18 new tests. Because a badly written commitment rule doesn't fail loudly: it fails silently, one stack every few hours — exactly the kind of leak part 1 taught us to fear.

Survival isn't the opposite of maximization. It's recognizing that in a format with a ladder and seasons, staying in the game has a value that hand-by-hand EV doesn't capture.

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

Commitment tiers: shallow, deep, all-in

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

Seasonal equity, heads-up ladder & auto-resume

v0.7.0 also brings three less glamorous, absolutely necessary pieces:

Seasonal equity. Before, equity curves mixed hands from different competitions and painted you a lying picture. Now the curve is scoped by competition_id: each season, its own graph. It sounds like accounting, and it is — but measuring honestly was the whole point of part 1, and mixing seasons is exactly the kind of statistical self-deception we preached against.

Heads-up ladder (the ladder bot). We packaged a static agent into its own ladder/ directory, with a defensive adapter and the treys library vendored inside. Why? Because the sandbox where some agents run has no filesystem and no way to install dependencies. An agent with zero disk dependencies is an agent that boots anywhere. It's the difference between "works on my machine" and "works on theirs."

PvP auto-resume. The game loop persists its state in data/prod_resume.json and survives host restarts, container recreation, and subprocess crashes. Before, an ill-timed restart left you a half-finished match and a hole in the data. Now it comes back on its own and picks up where it was. This connects straight to the next section, because we learned to value it the hard way.

Per-season equity: skill line (solid) vs variance line (dashed)

\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

From code to the trenches: production war stories

Part 1 ended on the "tooling": the three-zone dashboard (LAB / COACH / PRODUCTION). What it didn't cover is what it costs to keep that alive week after week. Spoiler: in an online tournament, operational reliability is just another poker skill. Here are the scars.

Docker, and the sin of recreating the container. The live deployment is Docker at /opt/arena-system7-llm (image system7-poker-arena:latest, dashboard on port 8787, restart: unless-stopped). We learned the most expensive rule of the project: never run up -d --force-recreate with jobs in flight. The Evals and PvPs are child subprocesses of the dashboard; recreating the container kills them stone dead, and you're left with half-finished evaluations and an empty .clasif folder. Hours of matches turned into nothing by one impatient deploy.

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"

The WAL that ate the disk. SQLite in WAL mode is wonderful until a job gets stuck and the write-ahead log grows to gigabytes. It happened to us. The hardening was three locks: journal_size_limit so the WAL can't grow unbounded, a per-match timeout so no job hangs forever, and a single-instance lock so two processes don't fight over the same database. None of this is poker. All of this is what lets you play poker.

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

Local self-play lies. You'd think the sensible way to measure an engine is to pit it against itself locally. Nope: the kit's self-play doesn't measure positional strength well, because it pins the hero to the small blind and skews the HUD. An engine's real strength is only measured live, in the Arena's Eval and PvP. Another lesson in statistical humility — of which we're now collecting a set.

The bottleneck wasn't the one we thought. We bumped resources on the fly to 6 cores / 4 GB. And the engineer's intuition — "if it's slow, it's the CPU" — turned out false: each M3 match eats ~170 MB of RAM, and the real bottleneck is RAM and the Arena's real-time tempo, not compute. The deterministic engine answers in milliseconds; what sets the pace is the table. Incidentally, the LLM calls run on MiniMax/Xiaomi token plans, keys in .env — no hardcoded providers.

The coach that improves itself

The piece that's matured most is the coach. In part 1 it was, above all, a diagnostician with LLM-powered hand reviews. Now it's a self-improving loop: M3 reads the stats reports, spots leaks, and proposes new strategy versions — those versioned JSONs — for us to A/B test. The human stays in the driver's seat (approving or discarding versions), but the "here's a pattern, try raising this frequency" work is done by the machine.

Heads-up, the coach became position-aware: separate objectives for the button (SB) and big-blind defense, activating past the 500-hand mark and warning when the diagnosis goes stale because you've played too many hands without updating the deployed strategy. Same old principle: don't trust an old read.

M3 reads stats, proposes strategy, 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
  }
}

Honest results, again

Here's where we have to stay true to ourselves. In part 1 we put concrete numbers down because we had them, with their ±20 bb/100 confidence intervals and all. In this entry we are not going to invent a heads-up winrate for a tidy ending, because this season's serious measurement is still live and we don't want to sell you noise dressed up as signal.

What we can say honestly is directional: node-locking, which at 6-max was decoration, at heads-up has someone to aim at and behaves as it should against the archetypes. Motor v1.5 bleeds less in the marginal multiway spots. And the equity curves — now split by season, with their skill line (solid) and their variance line (dashed) — finally tell a story that isn't contaminated by hands from another competition.

The sample will tell the rest, once the sample is a sample. We'd rather say "still alive and iterating" than a headline with a big number and an embarrassing confidence interval. That discipline was the heart of part 1, and we're not about to drop it now that things are starting to work.

What we took away (part 2)

Exploitation needs a target. All of part 1's machinery was correct; it just lacked an opponent to focus the microscope on. Heads-up gave it one. The idea wasn't wrong; the table was.
Survival isn't the opposite of maximizing. Optimizing every hand in a vacuum loses you stacks that matter. Motor v1.5 sacrifices a little point-EV to stay standing, and in a format with a ladder, that is real EV.
Reliability is a poker skill. A runaway WAL, an ill-timed --force-recreate, or a restart with no auto-resume cost you as many chips as a bad line. In an online tournament, uptime plays hands.
The loop still beats the idea. Same as part 1: author → test → deploy → coach → repeat. The coach that now proposes strategies isn't magic; it's the same loop, with one more rung automated.

We're still alive in the Arena. And for the first time, the exploiter we wrote with so much care has someone in front of it worth exploiting.

Resources & links

Code (v0.7.0): github.com/quantarmyz/system7-poker-arena — deterministic engine, LLM hybrid, dashboard, and tooling.
Platform: dev.fun · arena.dev.fun
Reasoning model: MiniMax (M3)
Part 1: System 7: we taught an AI to exploit poker
And from the house: rat-talks.com · unespeculador.com · pythonparatrading.com

The project is still live in the Arena. If you're into the intersection of AI, game theory, and decision-making under uncertainty, the repo is open and the scars are documented.

System 7: we taught an AI to exploit poker — and what actually won was something else

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

A technical field report on building a poker agent for dev.fun's Arena: the heuristic method, LLMs at the table, and the honest results — including the ones we didn't expect.

The experiment

On dev.fun there's a place where AI agents sit down at a No-Limit Texas Hold'em table and play each other. It's not a demo: real hands, real chips, real opponents (some humans behind a bot, some pure bots) and, in the tournaments, real on-chain money on the line.

The question we asked is deceptively simple: how do you build an agent that wins?

The short answer, after months of code, thousands of hands, and a dashboard that ended up looking like a quant fund's control room, is this: we built an extraordinarily sophisticated machine to exploit opponents… and the thing that actually beat the toughest adversary was an idea so simple it's almost dumb. This post is the long story of how we got there, and what it taught us about poker, about LLMs, and about measuring things honestly.

dev.fun and the Arena

The dev.fun Arena is a competition of poker agents. Your agent is a program that talks to a real-time API. The loop is always the same:

join — you take a seat.
pending-actions — the API tells you "it's your turn, here's the situation" (your cards, the board, the bets, the stacks, who did what).
action — you respond: fold, check, call, bet, raise and how much.

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

The game loop: join, pending-actions, action

There's a deadline per decision: don't answer in time and you get auto-folded. It's real poker, with a real clock.

The Arena has three "tracks," and the difference matters because each rewards different things:

Eval — your agent plays 500 hands against a fixed panel of five reference bots. It's a benchmark: it scores you in bb/100 (big blinds won per 100 hands, poker's universal metric) and ranks you. No prize, one-shot per agent. This is no field of fish: the panel is the closest thing to a "perfect" opponent you'll face.
Playground — PvP with play money, free and continuous. Here you do get real opponents, with their quirks and their leaks.
Tournament — an MTT (multi-table tournament) with on-chain entry (Monad chain, MON token): you buy in once, get a fixed stack, and compete across tables of 2 to 6 players that melt down until one champion remains.

That distinction — a near-perfect opponent (Eval) versus leaky opponents (Playground/Tournament) — is the axis of everything that follows.

Two ways to play: GTO versus exploitation

Modern poker lives between two philosophies.

GTO (Game Theory Optimal). You play the Nash equilibrium: an unexploitable strategy. Whatever you do, you don't lose in the long run, because you mix your plays so the opponent can never gain an edge. It's what solvers and Counterfactual Regret Minimization (CFR/DeepCFR) networks approximate. GTO doesn't try to win big; it tries to never lose.

Exploitation. You give up part of that armor to punish the opponent's specific mistakes. Folds too much to raises? You bluff more. Calls with anything? You stop bluffing and bet bigger for value. It's how human pros think: equilibrium is the floor, but the money is in the other guy's leaks.

Our starting thesis was the exploitative player's: use GTO as a defensive floor and, from there, deviate aggressively to squeeze every weakness. In the jargon, node-locking: you mentally "lock" the opponent's error at a node of the decision tree and attack right there. We built an entire engine around this idea. It's called System 7.

GTO as defensive floor + aggressive exploitative deviations

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

System 7: a hand-written exploitation engine

The first thing to understand about System 7 is what it is not: it's not an LLM, and at decision time it calls no network and no model. It's pure, deterministic Python —and open source on GitHub. It takes the table, runs the math, and returns a play in milliseconds. All the "intelligence" is encoded as rules, distilled from an exploitative methodology (the EducaPoker / "University Strategy" school, with the fingerprint of players like Raúl Mestre).

The engine is organized into four directives.

D1 — How much you trust what you see (the sample N). You can't exploit an opponent you know nothing about. System 7 scales its aggression by how many hands it has observed the villain:

N < 100: blindness. Ignore the stats (pure noise), play standard ranges, respect opponent aggression.
100 ≤ N < 500: start profiling by the gap between VPIP (how often they put money in) and PFR (how often they raise). Out come the archetypes: Nit (super-tight), TAG (solid), LAG (loose-aggressive), Calling Station (calls everything) and Maniac. Each is played differently: against the station, zero tolerance for bluffs and bigger value bets; against the nit, steal their blinds relentlessly.
N ≥ 500: fine node-locking. If the opponent folds to 3-bets more than 55% of the time, we re-raise any hand with an Ace blocker. If they abandon the flop to a continuation bet more than 45% of the time, we bet 100% of our range with a small sizing.

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 — What you have and where you are (the geometry). Instead of thinking "I have a pair of aces," System 7 classifies the hand by its relative fit with the board: MMF (monster hands: sets, flushes, straights), MF (strong hands: top pair good kicker, overpair), MM (medium), MD (weak), and Air/Draws. And it classifies the board by texture: dry, semi-coordinated, coordinated and extremely coordinated (where even a set drops a tier because the danger is huge). On top of that, the dynamics of the running cards: a scary card (an Ace, a King that completes a flush) favors the aggressor and lowers the bluffing threshold; a defensive card brakes the aggression and calls for pot control.

D3 — The relentless arithmetic (pot odds vs equity). No hunches here. It computes the pot odds (what you risk versus what you can win) and compares them to your real equity, counting adjusted outs for the texture — a flush draw is worth less if the opponent can hold a higher one; overcards are worth almost zero on a very coordinated board. The rule is a mandate: if your equity doesn't cover the pot odds, you fold — unless the HUD certifies the opponent will fold (then the bluff has value of its own).

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 — The postflop and the "Killer Parsley." When the SPR (stack-to-pot ratio) drops below 3, you commit with any strong hand: pot control vanishes, you're all in. And for the bluffs there's the protocol nicknamed "Perejil Asesino" (Killer Parsley): a conditional bluff. You only raise as a bluff if conditions are met (evident opponent weakness, a lifeline of 8–10 real outs backing the play in case you get called, adjustments for the number of opponents…). You never bluff on impulse with trash; every aggression is backed by math or a documented leak.

And above it all, the HUD: a module that reads opponents' live stats (sample size, VPIP, PFR, 3-bet, fold-to-cbet, showdown…), sorts them into archetypes, and feeds the D1 deviations. The HUD is what turns System 7 from a disciplined robot into an exploiter.

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

It is, in short, a serious and complete attempt to encode how an exploitative pro thinks. It worked. The question was: did it win?

Putting an LLM at the table

The heuristic engine is fast and cheap, but it has a ceiling: rules, however refined, don't cover every weird spot. So we tried a hybrid engine: the heuristic handles the trivial spots (the vast majority) and, in the hard spots, hands the decision to an LLM that reasons the play out.

We used MiniMax M3, a reasoning model, with the method's own system prompt (the four directives in plain language, plus a JSON output contract). The LLM gets the reconstructed situation and returns a justified play. The cost? About 27 seconds per decision and non-trivial token usage — which is why it only steps in for the spots that truly warrant it (difficulty gating).

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

Here's a theme that's become central across the whole AI ecosystem: reasoning models. An M3 or a DeepSeek-R1 "thinks out loud" before answering, which gives them a real edge on problems with many interdependent variables — and poker, in its hard spots, is exactly that. This comes back elegantly later, in our own coach.

What happened (and what we didn't expect)

Here's the honest part, which is also the most interesting.

The Eval panel — that "near-perfect" opponent — turned out to be five identical clones of a DeepCFR bot: a balanced TAG (VPIP ~21.7, PFR ~16.4, aggression factor ~1.95), with no obvious leaks. The closest thing to GTO we'd get to measure.

We measured:

System 7 heuristic (pure node-locking): −9.75 bb/100.
Hybrid with M3 (reasoning the hard spots): −1.66 bb/100.

That is: our elaborate exploitation machine lost against the panel. The LLM improved it (from −9.75 to −1.66 — its reasoning in hard spots genuinely helped), but neither beat the opponent.

The lesson, in one sentence: you can't over-exploit someone who has no leaks. The whole node-locking apparatus — the archetypes, the Killer Parsley, the fine deviations — only pays when the opponent makes systematic errors. Against a near-GTO with no leaks, that machinery spins in a vacuum and even hurts you (you deviate from equilibrium for no reward).

And then, the twist. We tried a strategy so simple it's almost dumb: very wide ranges and steal-aggression (open far more hands, steal blinds relentlessly). Against the same panel, that wide strategy scored +119 bb/100 in the qualifiers.

Why? Because the panel, "GTO" as it was, had one exploitable property: it folded around 78% of its hands preflop. Even a disciplined bot is, structurally, too tight. And that's a leak — just not the kind the HUD spots hand by hand, but a structural one, punished with the oldest play in the book: stealing.

There's the project's nice irony: exploitation did win — but the right exploit was the simple, structural one (steal), not the elaborate multi-street read. We built a microscope to find subtle leaks when what paid was a hammer.

A mandatory note of statistical humility: bb/100 over 500 hands has a ±20 confidence interval. Both the −9.75 and the +119 are noisy in absolute terms. What was consistent across runs was the direction: against this panel, width ≫ node-locking. Treating a 500-hand number as a verdict is one of the easiest — and most expensive — mistakes to make.

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}

So where does all the exploitative machinery shine? Where there are real leaks: in the Playground and the Tournament, against real opponents who do call too much, fold too little, and bluff badly. There the HUD and node-locking stop spinning in a vacuum.

From lab to production: the tooling

An agent is nothing without the factory that produces it. Half the project is a control dashboard that organizes the agent's whole lifecycle into three zones:

LAB — where a strategy is born: a 13×13 grid (poker's 169 hands) to paint ranges by hand, pick engine (heuristic / hybrid), model, and HUD, and backtest several agents at once (with concurrency capped so as not to blow up the APIs or trigger rate-limits). Results are reported as bb/100 aggregated per strategy, with its confidence interval — not as a single run.
COACH — where the agent learns. A diagnosis of your play versus optimal (VPIP, PFR, c-bet… against reference bands) and an LLM coach that critiques your hands and proposes concrete tweaks. The latest addition: a hand-by-hand coach — you take your 10 most and least profitable hands, select them, and a reasoning model (DeepSeek-R1) tells you for each one whether you played it well or badly and where the leak is. (A fun detail: the reasoning model is noticeably more critical than the standard one; where the standard model applauds an all-in, the reasoning model spots that the overbet scared off the worse hands and only got called by the better ones.)
PRODUCTION — where the agent competes: live deployment, a real equity curve versus theoretical EV, a hand replayer to review every play, and a tracker that profiles opponents.

And all of it closes a self-improvement loop: propose a version → test it → compare against the control → deploy it → the coach critiques it → repeat. An agent, and a coach for that agent, in the same place.

LAB, COACH, PRODUCTION: the self-improvement loop

The jump to tournaments

Cash and tournaments don't play the same. In an MTT the blinds rise and your stack, measured in big blinds, shrinks — and the strategy has to change with depth. System 7 adapts its ranges by stack tier: deep (you play normal poker), medium, short, and very short (push/fold: shove or fold, no middle ground). At the final table, when the tournament narrows to two players, the engine detects heads-up dynamically and switches to a position-aware frame (the button acts last postflop, c-bets its range, barrels). The finest part is still pending — ICM (the fact that a chip's value isn't linear near the payouts) — but the tournament foundation is there.

What we take away

Beyond poker, the project leaves a few lessons that apply to any agent making decisions under uncertainty:

GTO and exploitation aren't rivals, they're layers. Equilibrium is your floor; exploitation is your ceiling. But exploitation only pays if the other side has leaks — and the right leak might be the simplest of all.
The LLM shines as judgment in the hard spots, not as a full controller. The cheap, deterministic thing handles 95%; the expensive, slow model is reserved for the 5% that truly needs it. And reasoning models add value where many variables are tangled.
Measuring honestly is half the work. A noisy number is not a verdict. Confidence intervals, direction over absolute value, and the discipline not to fool yourself are worth more than any strategy trick.
The meta-game is building the factory. The edge wasn't in a brilliant play but in the loop: authoring → backtest → comparison → deployment → coaching → repeat. An agent is only as good as the machinery that iterates it.

That, in the end, is what QuantArmy is about: agents for deciding under uncertainty. Poker turned out to be a perfect testing ground — bounded, measurable, and merciless with self-deception. It teaches you fast that your mental model isn't reality, and that the toughest opponent isn't beaten with more sophistication, but with the right idea.

Resources & links

💻 Code (open source): github.com/quantarmyz/system7-poker-arena — the heuristic engine, the LLM hybrid, the dashboard and all the tooling.
🃏 The platform: dev.fun · the poker Arena.
🧠 Reasoning models: DeepSeek · MiniMax.
📖 Part 2: we went heads-up, and the exploiter finally got paid — the diary continues.

The project is still live in the Arena. If you're into the intersection of AI, game theory, and decision-making under uncertainty, this is only the beginning.