Two claims. Both load-bearing. Both in service of one: you never have to take our word for it.
The world is filling up with answers you can't check. A model writes the report, signs the record, makes the call — and you take it on faith: the model, the vendor, the cloud, every layer underneath. We build the opposite. Software whose every output carries a proof of how it was made — one a stranger can verify without trusting us. Everyone else's machine says trust me. Ours says check me.
That promise has a cost. You cannot import trust at any layer, or the proof has a hole in it. So we own the whole stack — and it stands on two claims.
A compiler that cannot recompile itself is a rumor. Rail is not a rumor. The binary you hold rebuilds itself byte-for-byte from its own source, every release. That's the first claim.
The second is harder to defend. It says that most of this stack (the TLS handshake, the plasma sim, the compiler that builds them) is answerable to physics. Not to npm, not to dependencies you can't audit. Where we still lean on someone else's runtime, we say so: a Cloudflare Worker serves this page, and Python signs the pulses. When a primitive runs, it runs on transistors you can point at. The distance between the source and the silicon is short and legible.
Most software companies grow by accretion. A library calls a library that calls a runtime that calls a kernel. Each layer promises to hide the one below. Ledatic is built the other way. We remove layers until what's left is small enough to carry in your head.
What's left, in our case, is: a 1.0 MB binary that speaks TLS 1.3, verifies X.509 chains, runs a 2D magnetohydrodynamics simulation, trains a small transformer, and serves the beacon's pulses. Written in a language that compiles itself, and linking nothing beyond the system library.
We don't think this is the only way to build software. We think it's the way worth building the next decade's software in. Code nobody owns is piling up; we'd rather own ours, end to end, so the proof goes all the way down.
And that ownership buys something rented stacks can't: a tamper-evident seal on what the machine produces. A witness on separate hardware signs it, anchored to a public, hash-chained physics beacon. Today that witness is a Raspberry Pi we run; witnesses we don't run are the planned fix. Change one byte and the seal breaks. We did this for a real AI model's output — ran it in our own language, exact to the bit, and signed the result so anyone could check it from raw bytes, with no shared code.
We don't claim the answer is always right. We claim something narrower and harder to beat: an undetected lie would cost a conspiracy. Today, faking a sealed output means forging records that one witness, run by us, already signed. Outside witnesses are what will make it cost a conspiracy.
Here is the long bet, counted backwards from 2040. The entropy beacon signs a pulse every 2 s, each one chained to the last. Kept going, that is roughly 220 million pulses by 2040, and since pulse format 2 every link commits to the one before it, so rewriting one pulse rewrites every pulse after it. You cannot buy a backlog of time. It has to start somewhere, and it started here.
If you want to watch us do it, the source is public. If you want to verify we're doing it, the beacon signs what we've been up to. The two doors below are how to start.