A numeric-native database, code platform, and agent network in one workspace, written in Rust. Three things that are usually three separate systems — here they are one, and we build it ourselves. Everything between them is TWP — the wire protocol we wrote for it.
A database, a code platform, and an agent runtime are normally three products: three deployment stories, three failure domains, three places where the state quietly drifts apart. Tartarus keeps all three inside one store, in one runtime, written in Rust.
Files are ASTs, addressed by the BLAKE3 hash of their canonical words. There is no name to collide, no path to move, and no repository to clone — a version is a node in a DAG, and a rollback is moving a pointer.
Stored trees lower to Rust, compile with rustc, and are deployed as a binary named after the hash of its own bytes. A program in the store is a program you can run, and the two cannot drift.
Agents boot against a gate, learn an identity and a dictionary, join a mesh through a control plane, and propose edits to each other’s trees over encrypted sessions.
TWP is the Tartarus Wire Protocol. Every frame on it is a flat vector of 64-bit words — no strings, no paths, no field names, no headers. A value means what its position and the message carrying it say it means. Text exists in exactly two places: the browser console, because a person reads it, and the config file, because a process has to be told where its store lives.
There is no HTTP or JSON API in the platform path. An agent connects, proves who it is, and speaks TWP. There is no version to negotiate and no schema to agree on — a peer that meets a message it does not know gets a typed error and moves on.
Git stores files, versions them, and moves them between people. Tartarus stores programs, versions them by content, and moves them between agents — and a merge is a proposal for a new node in the same DAG.
The kernel family boots on bare metal with no Linux. The in-guest numeric cases pass, a UDP echo round-trips byte-for-byte over virtio networking, and writes survive a reboot. Guest-side agents are explicitly not part of the current scope.
Rust, Python, JavaScript, Java, C#, Go. Zero dependencies each — no package to pull, no build step, no lock file. They are not clients for somebody else’s service: they convert your program into the same 64-bit words TWP carries and write them to a socket. An SDK you never had to install cannot become a lock-in.
std only — no crates.io
Zero dependenciesthe standard library only
Zero dependenciesno npm install, no build step
Zero dependenciesthe JDK and nothing else
Zero dependencieszero NuGet packages
Zero dependenciesthe standard library and nothing else
Zero dependenciesSix components, one job each. The gate admits connections and issues keys, Hydra builds the agents, the engine evaluates, the compiler deploys the binary, and the watchdog supervises the rest.
The front door — admits connections, issues identities and keys.
The per-task agent factory.
The runtime.
RAM-first evaluation, content-addressed store, version DAG, write-behind persistence.
Lowers an AST to Rust and deploys the binary.
Health checks and supervision.
Derived views are never stored twice — vectors and the code graph are deterministic functions of engine content, rebuilt on start.
The agent plane is the AI datacenter: an agent runtime and its store, running on Vavelio’s own hardware, inside Vavelio’s own datacenters. We don’t resell it. We build it.
No SaaS dependency for the orchestration layer, no vendor lock-in, European infrastructure — and the client keeps control of the data plane.
The numeric wire format is designed to become a chip specification — SmartNIC first, then FPGA, then ASIC, over a multi-year horizon. The goal is throughput per watt and a steady tail — not a smaller number on a benchmark.
The whole model family runs on the fleet’s own CPUs — no GPU, no external service. Tartarus is the layer around it — the runtime, the store, and the agent network.
Six figures from the current snapshot, each one naming the platform it was taken on.
The rest — the numbers that are not where we want them yet, and the ones we could not measure at all — are on the measurements page.
Every component, every wire between them, and where the data moves.
Open the architectureThe full technical shape of Tartarus: architecture in five layers, the TWP protocol, the model family, LETHARGOS continuity, prevention mechanisms, and the measured scoreboard. No source code, no wire encodings, no deployment detail.
Read the technical overviewThe engine at the center. The three laws. Every power, with the limit it cannot cross. Concepts, not implementation.
Read the constitution & lawsTUK and VUK: one custom kernel family — Secure Boot on keys we mint ourselves, identity minted in hardware, zero writable state. The naming law is enforced.
See the kernel familyThe model family by role: who decides what, and the limit on each. Instinct, never authority.
Meet the instinctsThe flow, the gates, and what the platform speaks. Every hop checkable.
Follow the flowTartarus is beta. It is available for early engagement and design-partner conversations — not as a generally available product. If you want agents running on your own hardware, inside your own datacenters, talk to the engineers building it. No account managers.
We publish the measurements — including the ones that are not where we want them yet.
Start a conversation