Production AI infrastructure.
Written in Rust. Open source.
From bare metal to autonomous agents. No JVM. No garbage collector. No dependency on someone else's cloud. Every component compiles to a single binary. Deploy it, and it runs.
Lys
Trust infrastructureIn developmentImmutable trace log. Cryptographic identity, tamper-evident history, and verifiable provenance. Trust you can verify.
Frame
Application frameworkIn developmentThe application framework. Where runtime, storage, workflows, agents, and trust come together into software people actually use.
What you get when the layers work together.
Each layer solves a hard problem on its own. The emergent properties of the full stack are what make it infrastructure — not a framework, not a platform, but the thing underneath that everything else stands on.
Durable agents as infrastructure
Not a tool you build with. A load-bearing primitive you can make guarantees about. Deploy one binary that survives crashes, shows its work, and runs forever. Processes die, whole servers die, you rip the power out of the wall — and the work is picked up by a sister server in the cluster.
Single binary. No dependencies.
No Postgres. No Cassandra. No external queue. No JVM. The entire stack compiles to a single binary with zero external dependencies. This is not a convenience — it is the product. Self-hosting means deploying one file and owning it completely.
Edge and browser native
Beamr and haematite both compile to WebAssembly. OTP in the browser — LiveView without the latency, offline-first for free. Tiny AOT modules for edge compute. The same code, the same content hashes, running anywhere from a data centre to a browser tab.
Durability is structural
Most systems bolt durability on after going distributed. The Ablative Stack has it first. Aion's event-sourced histories, haematite's immutable content-addressed trace, beamr's OTP supervision — the agent's progress is persisted and recoverable by construction, not by configuration.
Think of the stack like a building. Each floor only depends on the floors below it, never the ones above. Fix or upgrade any layer without accidentally breaking something else. That reliability is structural, not accidental.
The strict dependency chain — beamr → haematite → liminal → aion → norn — means each layer depends only on those beneath it. No circular dependencies. No hidden coupling. You can use the lower layers independently, but the higher layers build on top of them — that's what makes it a stack.
Why Rust?
AI infrastructure is the wrong place for garbage collection pauses. Every component compiles to a single binary — memory-safe, concurrent, deterministic. The infrastructure disappears. You notice the system working, not the system struggling.