← All work

Diametric

Two adversarial AI entities, co-evolving

Last devlog: June 19, 2026

THE FORGE LOOP — MANY RUNS, PRE-COMMITTED MEASUREMENT scores each run: margin trajectory · convergence on the edge · tactic diversity · both sides adapting FAST CLOCK — DETERMINISTIC · HOT PATH · BYTE-IDENTICAL FOR A SEED Entity AReaches terminusdeterministic policyEntity BHolds the edgedeterministic policyEncounter EngineTick-by-tick clash resolutionpure Rust · pinned PRNG← THE LULL · LLM NEVER CROSSES INTO THE ENCOUNTER → SLOW CLOCK — PROBABILISTIC · BETWEEN ENCOUNTERS ONLY Context DaemonClash → computed factsdeterministic · never raw logsThe StrategistLocal LLM · reads factsJSON-validated · lull onlyArc-MemoryCarried knowledgewinner persists · loser re-seedsTHE KNIFE'S EDGEB sustains pressure without finishing Aencounter outcomefactsadjustments (JSON)carriedknowledgescores →measurement

Key boundary: The LLM never runs inside the encounter loop. It reads a compact record in the lull between encounters and proposes adjustments for the next one; the encounter itself is pure deterministic Rust, byte-identical for a given seed. Two clocks — a fast deterministic one that owns the real-time clash, and a slow probabilistic one that shapes it between clashes.

Why it matters: An LLM in a real-time loop is a latency bomb and a determinism solvent. The boundary is what keeps the contest fast, reproducible, and trustworthy — and what lets you reason about the system at all.

Notable decision: Determinism is clock-split. The fast clock is byte-identical for a seed; the slow clock (the LLM) is reproducible by replaying its logged outputs, not by re-running it. Two different, honest notions of "reproducible," one per clock — so the system stays verifiable even though half of it is a probabilistic model.

A game where two AI entities co-evolve through repeated encounters — one trying to end the other, one trying to survive and, in surviving, generate the curriculum that makes its opponent harder. The architecture is deliberately split: deterministic Rust owns every real-time encounter (fast, predictable, fully under the engine's control), while the language model is confined to the role of between-encounter strategist, adjusting approach only in the gaps. It's a working answer to a question I keep circling — where does an LLM belong in a real-time system? Here, never in the hot path; only in the space between, where deliberation is cheap and latency doesn't matter.

The recent work turned it into something I didn't fully expect: a small emergence experiment with a definition of "emergence" committed to in advance. Pitting a fixed strategist against a learning one, the learning version didn't produce a clean victory — it hit its target and quietly lost something doing it: the behavior band converged while diversity collapsed. A subtle plateau, not a gross one, distinguished from its opposite by a single pre-registered lever. The honest negative-shaped result is the part I find most interesting, and the reason this is the long bet of the bunch — and the one I'll keep writing about as it grows.

Devlog posts about Diametric

Three walls in vLLM structured output — and the method that found them

A local LLM that only thinks between encounters meant putting Qwen behind a strict JSON contract. Here are the three substrate walls that cost me time — and the working method that surfaced each one, because the method is the part worth copying.

How do you know if your AI actually learned anything?

I built two AI entities that adapt to each other between encounters. Then I had to answer the harder question: is the adaptation real, or does it just look real? The honest answer this time was 'not yet' — and the reason that's the post worth writing is that the system could prove it.

The bug disguised as a parameter

Two findings from Diametric's build floor. Both first looked like 'tune the number,' and both were really 'change the structure.' The useful part isn't the bugs — it's that the system was built so it could hand them to me instead of hiding them. The architecture that can contradict you is the one worth having.