SELF-EVOLVING AGENTS HACKATHON · SAN FRANCISCO

EVOLVING POKER

Four LLMs play poker and rewrite their own strategy after every hand.

Every action is a model decision. Every rewrite is proposed by the model, applied live, and rendered as a readable diff — including the ones that fail.

4

AI PLAYERS

4

DIFFERENT MODELS

6

HANDS

0

HIDDEN CALLS

Pioneer · Band · Replay · cited.md

EVOLVING POKER · 02

THE PROBLEM

Everyone claims self-evolving agents.

Almost nobody can show you the evolution.

CLAIMED

“Our agents learn from experience.”

SHOWN

A chat log, and a chart that goes up.

MISSING

What changed, when, why — and whether it helped.

Why it stays unfalsifiable

Real agent work is unscoreable.

Did the research agent do a good job? Nobody can say.

And feedback is noisy.

A good decision can lose. A bad one can win.

So we picked the one environment where the rules of the game solve both.

EVOLVING POKER · 03

THE ENVIRONMENT

Poker is the lab, not the product.

Objective outcomes

Chips won or lost. No judge, no vibes, no LLM grading another LLM.

Noisy feedback

You can play perfectly and lose. Overreacting to one hand is a measurable mistake.

Repeated opponents

The same four agents, hand after hand. There is genuinely something to learn.

Legible to anyone

“It bluffed too much, then stopped” needs no ML background to follow.

Swap poker for pricing, bidding, negotiation or routing — the loop is unchanged.

EVOLVING POKER · 04

HOW IT WORKS

One loop, six times.

01

DECIDE

Each agent sees its cards, the pot, and its legal moves. It picks the action.

›

02

OBSERVE

Every action, bluff, showdown and chip delta is recorded as public evidence.

›

03

REFLECT

The model reads its own results and decides: rewrite a dial, or hold.

›

04

REWRITE

Validated, applied instantly, rendered as a diff. The next hand uses it.

The weights never change. The strategy does.

Same model, same prompt shape, every hand. What evolves is external, inspectable state — a file you can read.

EVOLVING POKER · 05

server/src/engine · server/src/evolution

THE ARCHITECTURAL DECISION

Agents decide. The engine enforces.

WHAT THE MODEL OWNS

• Every fold, check, call and raise — from a legal-action list
• Its own three strategy dials, rewritten between hands
• Which Pioneer model it runs on next

WHAT THE ENGINE OWNS

• Legality — an illegal move becomes a mechanical check or fold
• Chip accounting and showdown evaluation
• What each seat is allowed to see

What this costs us — and why we paid it

A live run is not deterministic. The seed fixes the deck, not the decisions. We could have kept perfect reproducibility by letting a pure function play every hand — but then the agent isn't the player, and the claim gets smaller. So we kept the agency and built the instrument instead: every call counted, every rejection fed back, and the noise floor measured by replaying the same seed twice.

EVOLVING POKER · 06

server/src/config.ts

THE TABLE

Four temperaments. Four models. One rule set.

ATLAS

THE AGGRESSOR

Apply pressure. Make them pay to continue.

0.85 / 0.25 / 0.40

aggr / bluff / call

Qwen3-8B

BOREAS

THE BLUFFER

Represent strength. Exploit anyone who folds.

0.60 / 0.80 / 0.50

aggr / bluff / call

claude-haiku-4-5

CIPHER

THE MATHEMATICIAN

Hand strength and pot odds over theatrics.

0.35 / 0.05 / 0.60

aggr / bluff / call

Llama-3.1-8B

DELTA

THE READER

Wait for repeated evidence, then exploit it.

0.50 / 0.25 / 0.50

aggr / bluff / call

DeepSeek-V3

Different starts, on purpose — so the table is already interesting at hand one, before evolution does anything.

It also separates two claims a judge should never have to untangle: these agents are different, and these agents changed.

EVOLVING POKER · 07

server/src/evolution/schema.ts

THE RULE WE REFUSED TO BREAK

We never babysit the models.

WE VALIDATE

• Shape — is it the JSON we asked for?
• Range — is every dial between 0 and 1?
• Transport — a dial sent as “0.45” becomes 0.45
• Timeouts — 20s, one retry, then hold and log

WE DO NOT ENFORCE

• No step-size cap — a model may swing a dial 0.50 in one hand
• No one-dial-at-a-time rule
• No anti-reversal rule — it may undo itself next hand
• No simulator approving changes before they land

Guardrails would mean we designed the intelligence, then measured our own work.

If a model panics and oscillates, that is not a bug we hid — it is the finding, and we count it. A rejected response is fed back into that model's next prompt, because a model that cannot see it was rejected will break the same way again.

EVOLVING POKER · 08

server/src/engine/metrics.ts

THE INSTRUMENT

Chips are the least interesting number on screen.

OSCILLATION

A dial moved ≥0.15, then reversed within two updates. Panic, quantified.

NO-CHANGE RATE

How often a model correctly refuses to act on noise. Restraint is a skill.

VOLATILITY

Total absolute dial movement — how much a model rewrites itself at all.

PARSE REPAIRS

Which model needed its output fixed, and how often. Per model.

ADAPTATION GAIN

Second-half chips/hand minus first. Labelled directional, this run.

LATENCY & COST

Per model, per call — live on screen and in the report.

The question isn't who won. It's who changed their mind well.

A model that holds steady through noise and moves once on real evidence beats a model that wins six lucky hands. Six hands is an existence proof, not a benchmark — and the report says so.

EVOLVING POKER · 09

evolution/pioneer.ts · action.ts

SPONSOR · 01

Pioneer — four models, one identical job.

Every agent action and every reflection is a Pioneer call. One OpenAI-compatible surface, four model IDs — and the comparison between them is the product.

MULTI-MODEL ROUTING

One base URL, four model IDs, swapped by env var. No client rewrite per provider — exactly the primitive this experiment needs.

AGENT-SELECTED MIGRATION

An agent may move itself to another model in MODEL_POOL between hands. Self-modification that reaches the model layer, not just the prompt.

STRUCTURED OUTPUT

Every reflection is JSON we validate, repair and count — and it has to hold across four different model families.

TOKEN & LATENCY METADATA

Returned per call, so cost-per-adaptation and speed-per-model are on screen live, not estimated afterwards.

Adaptive Inference

Our traffic persists to Pioneer for inference history, evaluation and clustering. Two layers of evolution: the agent rewrites its strategy, the model improves underneath it. A six-hand run does not claim a retraining cycle completed — we won't overclaim yours either.

EVOLVING POKER · 10

server/src/comm/band.ts · trace.ts

SPONSORS · 02 — 03

Band carries the table. Replay proves it works.

BAND

Four registered remote agents, one shared room.

Each seat is an addressable agent with its own identity and key — not a function call. Actions, hand summaries and evolution events publish through Band's REST API with real sender identities and recipient mentions.

turn_action

player → room. Fold, check, call, raise.

hand_summary

dealer → all. Winner, pot, chip deltas.

evolution_event

player → all. “Here is what I changed, and why.”

The Agent Wire on screen IS this trace, rendered live. Every line the audience reads went through Band.

REPLAY

QA on the deployed spectator app.

External QA — no SDK, no key, no environment variable. The deployed app is submitted and tested the way a user would meet it.

JOURNEYS

• Tournament starts
• Chips stay conserved
• Evolution cards stream
• Timeout path renders
• Standings appear

EVOLVING POKER · 11

CREDIBILITY

What we will and won't claim.

WE CLAIM

• Agents choose every action and rewrite their own strategy after every hand.
• They act on real outcomes, not on prose about outcomes.
• Every change is visible, attributable and replayable.
• We measure adaptation, restraint, stability, cost and latency together.

WE DO NOT CLAIM

• That six hands prove one model is better than another.
• That this is training — no weights were touched.
• That the agents become optimal, or even good.
• That luck was eliminated — it wasn't, which is exactly why overreacting to one hand is the mistake we measure.

What's new here isn't poker, and isn't evolution. It's evolution you can read line by line while it happens.

THE ONE LINE

Four models.

Four temperaments.

They rewrite themselves

while you watch.

And every rewrite is a line you can read, an evidence ID you can check, and a message you can replay.