Kronik: a runtime that replays production traffic through new code
Don't deploy code you hope works.
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.
[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.
- 36,214
- requests replayed
- 35,990
- answered the same
- 224
- would answer differently
The build brief's own example: an hour of billing traffic, replayed through code that adds EU VAT.
Replay the old code instead, and the diff is empty.
Nothing differs by accident, because time, randomness and outside answers all come from the record. So what does show up is the change.
This is the behavior diff.
What would change, shown before anything ships. You read this, not ten thousand lines of code.
kronik diff show p-7h3kResponses 224 changed, 35,990 identical
Effects 224 changed, 0 added, 0 removed
Errors 0 introduced, 0 fixed
It also says what the change costs, and how sure it is.
Compute per request is measured on the replay. And every outside answer is graded exact, approximate or synthetic, so you can see what the result rests on.
kronik diff show p-7h3kResources fuel p50 +1.2%, p99 +3.1%
Grounding 36,766 exact, 224 approximate, 0 synthetic
Confidence 0.99
payments-must-be-exactApproval required
A policy reads the diff: allow, ask a person, or deny.
Here a payment changed, and the rule for payments sends it to a person.
Agents work inside the same rules.
An agent can read history, fork it and propose a change. It cannot approve or promote. And in its forks, tagged names, emails and other personal text show up as pseudonyms.
A person reads the diff and approves it.
With a reason, and on the record. The approval covers this diff and no other.
Then production switches to the new code.
First Kronik replays whatever arrived since the proposal and checks the policy once more.
If it still goes wrong, the data can go back too.
Roll back by replay, and everything since the deploy runs through the old code: the state becomes what the old code would have made. Calls that already went out are listed, because nothing can take them 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.
| Kubernetes | Temporal | Kronik | |
|---|---|---|---|
| Its question | Is it running? | Did the workflow finish? | Will the change behave? |
| What it runs | Containers, in any language | Workflow code, on workers you host | Actors: Wasm components with their own state |
| Clock, randomness, network | Read freely by the container | Controlled inside workflow code | Handed to actor code by the host, and recorded |
| Recorded history | Logs and events, for people to read | Replayed to recover a run | Replayed to recover, and to show what a change would do |
| Check before a deploy | The tests and staging you build | Replay test: old runs pass or fail on new code | Replay of real traffic, reported as a diff |
| Rollback | The previous pod template; data stays as written | The previous worker version; a reset restarts one workflow from an earlier point | The previous code, and the state it would have made |
| State | A database you run beside it | Workflow state; other data elsewhere | Key-value and SQLite per actor, rebuilt from the log |
| Maturity | Mature, in wide production use | Mature, in wide production use | Pre-alpha, one node, not ready for production |
| License | Apache 2.0 | MIT | Elastic License 2.0, source-available |
Kubernetes and Temporal as their own documentation describes them in November 2026: Deployments, probes, safe deployments, reset.
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.
310,611
lines of Rust.
About half of them are tests.
2,458 tests. 1,000 forced crashes and 30,000 simulated runs, without one violation.
It holds itself to the same test.
Before a new Kronik takes over, it replays your last six hours with your code unchanged. The diff has to be empty.
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 in its build brief are implemented. Not built yet: the cluster. Not done yet: an outside security review and a production pilot.
Version 1.0 is a cluster of three servers that survives losing one.
By then approval happens in a web interface, upgrades roll through the cluster one server at a time, and the formats come with a compatibility promise.
The bet: code that agents write will run where it can be checked.
The earlier levels each had a translator people could check. This one has a runtime that shows what a change would do.
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.
Don't deploy code you hope works.
See what it would have done with yesterday's traffic.
Read the sourceRead the build briefSee the project status
Kronik is pre-alpha and source-available under the Elastic License 2.0. Kubernetes and Temporal are trademarks of their owners.