Kronik: a runtime that replays production traffic through new code

Programming keeps moving up a level.

At the bottom, machine code: 11110010 00001111 01011001 …

1950s

First, assembly: words in place of raw numbers.

An assembler translates them, one for one.

mulsd xmm0, [vat]

1957 to 1973

Then compiled languages: Fortran, then C.

A compiler writes the machine code, so people no longer had to.

total = price * vat;

1990s

Then managed languages: Python, Java, JavaScript.

A runtime looks after memory, so people no longer had to.

totals = [p * vat for p in prices]

Now

Now the level is English, and agents write the code.

Google, April 2026: “75% of all new code at Google is now AI-generated and approved by engineers.” Source

“Add VAT to EU invoices.”

Every earlier step rested on a translator people could check.

A language has defined rules. The same source can be made to give the same program, every time.

An agent makes no such promise.

Ask twice, and you can get two different programs.

And it writes faster than anyone can read.

Tests pass. Staging is green. Production still surprises you.

So review moves up a level too: from what the code says to what the code does.

The code still matters. It stops being the first thing a person reads.

Kronik starts from a log.

A plain record of everything a system does, in order.

Every request, every outgoing call and every state change is written down before anything is answered.

That makes a system a function of its history.

Same code, same history, same result, byte for byte. Even the clock and the dice come from the record.

Propose a change, and Kronik forks that history.

Recorded traffic runs through the new code.

The last hour, or all of yesterday. Outside calls get their recorded answers, so no card is charged twice.

A policy reads the diff: allow, ask a person, or deny.

A payment changed, so this one needs a person. Agents can propose. They cannot approve.

Approve and promote: production switches to the new code.

If it still goes wrong, roll back.

Why not build this on Kubernetes?

Kubernetes keeps containers running.

It starts them, restarts them and rolls out new versions. Its question: is it running?

What a container does inside is its own business.

It reads the clock, rolls dice and calls the network as it likes. Kubernetes records none of it, so it has nothing to replay.

Kronik hands code its time, its dice and every outside answer, and writes each one down.

Replay needs a runtime that owns those three things. Kubernetes leaves them to the container.

So Kronik is its own runtime: 25 crates, one binary.

State, messaging and timers are built in. Actors are written in TypeScript, Rust, Python or Go.

And it runs on one small server.

Its own benchmark, on a two-core test machine: about 2,770 committed turns a second, and replay more than 20 times faster than real time.

Five releases so far. The latest, v0.5.0, shipped on 15 November 2026.

It is pre-alpha. Don't run production on it yet.

140 of the 196 criteria are implemented. Still open: the cluster, an outside security review and a production pilot.

Version 1.0 is a cluster of three servers.

Every change, from a pull request to an upgrade of Kronik itself, goes through the same replay.

The source is public. One right is reserved: hosting Kronik for others.

Elastic License 2.0.

That is the business: a managed Kronik cloud, and licenses for the clouds that want to run it.