Every component, every wire between them, and where the data moves. The platform runs as a fleet of purpose-built machines on the unified kernel family — one service per image — and the trust plane now sits beside the numeric core, not behind it.
The platform as it runs: the human edges on the left, the numeric core in the middle, the derived views and the perimeter roles on the right, and the mesh and the fleet of purpose-built machines below. Drawn in vector, in the same hand as the system it describes.
The platform architecture — every component, every wire, and where the data moves.
Open the full-screen diagramEvery component in the platform sits in one of nine zones. The dashed boundaries are scope and trust boundaries, not decoration — a zone drawn dashed is a zone the data does not cross freely.
The client is the single human surface; the SQL shim, the SDKs and ingestion are human edges too — and every line out of them becomes typed numbers.
The engine store and the single write steward live here — there is no text plane inside the core.
A court of three judges, the authority that issues machine identity, netrules that may only be tightened, and supervision domains rebuilt from their configuration — never mutated.
A family of small specialized models — gatekeeper, shield, smith, voice, shaper — served through the model gate; no model is reached directly.
Work runs under a lease: a plan, an arbitrated execution window, and the domain and binding rules that say where a task may run.
The vector index and the code graph: deterministic functions of engine content, never stored twice.
Three roles at the edge — who may enter, what is carried across, where a crossing is allowed — held as roles, never as addresses.
One service per image, every machine under Secure Boot with our own key, and identity keys minted sign-only in hardware.
Supervision, heal events and telemetry: ops observe and restart, they never write content.
These are the components that carry the platform — each card names the component, the role it holds, and what it provides. Roles, not addresses: where something lives is deployment detail, and deployment detail is not published.
One native desktop application: tasks, artifacts, the model family and the license door — the single place a human meets the platform.
The SQL shim, the SDKs in six languages, and ingestion from CSV, JSON, SQLite, Postgres and MySQL — every one a text door that becomes typed numbers.
Nothing writes to the engine except through the steward, and it re-indexes the derived views before a write is acknowledged.
A content-addressed store of typed trees — RAM-first, with a write-behind steward for durability.
Task plans, leases over an arbitrated execution window, and the domain and binding rules that decide where a task may run.
Registration and discovery for the mesh: a member is admitted by its identity, and absence from the set is the verdict.
The workers: each holds a lease, proves who it is, and speaks the wire — one authenticated session per agent.
Lowers stored trees to code and compiles them — the one component that carries a compiler.
Every model request is routed, selected and scaled here; a model is never reached by naming it.
Three judges, one watch each: a verdict of two of three, and a final appeal — the only path to destroying a power.
The court's own append-only store, walled to the judges: dockets, verdicts and case history.
The sole issuer of machine identity — the sign of authority, the kill, and the order that binds them.
Suggest, apply, revert: typed rules over the boundary — a rule may only be tightened, never loosened.
A deterministic function of engine content — re-indexed before a write is acknowledged.
A deterministic function of engine content — the frames are caches, not the truth.
TWP is the Tartarus Wire Protocol. Every frame is a flat vector of 64-bit words — no strings, no paths, no field names, no headers.
Text exists only at the human glass and at foreign edges — the client on one side, the outside world on the other. Inside the platform path there is no HTTP, no JSON, and nothing to parse.
Tartarus, TWP, the protocol specification, this architecture and the SDKs are the property of Vavelio LTD. No licence is granted to reproduce, adapt or redistribute them, except the specific open-source licence stated on an individual component.
The company registration, the trademark and the domain management are on the legal page.
Three places worth reading.