Vavelio LTD · London · October 2026 (public edition). What follows is the full technical shape of Tartarus. It contains no source code, no wire encodings, no addresses, and no deployment detail — those are deliberately withheld. Everything else is here.
Software has been stored as text for seventy years. Tartarus stores software as structure: every function, type, dependency and relationship lives in a purpose-built database as code itself — not as rows describing code. We call this numeric-native: the platform's unit of data is the same unit a compiler manipulates.
On that foundation runs an agent network: AI workers that recon a repository, convert it into the engine's native form, explain it in plain language, and synthesize new software from it — under strict, named authority, on a network fabric designed from first principles.
The core is a code database: data IS structure. Repositories are not stored as files but decomposed into a typed structural form (functions, types, call edges, ownership) that the database queries natively. Analysis becomes exact (structural) rather than statistical, and synthesized output is generated from the structure — which is why the platform can build software, not just talk about it. Implementation: a Rust workspace of ~60 components — 56 workspace crates across 59 crate directories — and ~5,500 Rust test functions, about 5,790 across the repository in all languages; counted October 2026.
Tartarus runs on a minimal data network built for typed meaning rather than generic bytes:
no TCP anywhere — the platform carries no general-purpose transport; a single narrow data path exists per machine
typed verbs — every message is a named verb carrying its own authority and interpretation; there are no free-form payloads to fuzz
queues of words — communication is structured as queues of typed words, not byte streams to parse
rings are wires — shared-memory queues between services are transport only; data never outlives the process that moved it
Smaller attack surface, tighter guarantees, and messages that cannot be confused for one another.
Every machine, service and agent holds a name that is also its security boundary. Authority is issued by a single root and cascades through named domains (platform core, the supervisor layer, the court, the user realm). Rules that make it hold:
one authority issues identity; nothing self-names
cross-domain traffic is narrow, typed control signalling — data does not flow between domains that don't need it
every machine runs a paired watcher set (integrity + supervision) — the system watches itself
each supervision domain's data plane is rebuilt from its configuration and never mutated in place — a domain's rows are written only by its own supervisor
infrastructure is defined as code and enforced below the operating system; drift is detectable by an empty diff
Judgment and evidence are first-class:
a court of three judges, one watch each, supervises every power and rules on disputes; a verdict needs two of three, and a split bench becomes the final appeal
one trust authority issues machine identity — the sign of authority, the kill, and the order — and holds no power to judge
enforcement is bound to judgment: a condemned power is destroyed only on a court ruling, by the one execution power
every meaningful action lands in an append-only mathematical record (a hash stream): the platform can be audited not by trusting logs but by verifying mathematics
the watchers and the conductor of time never sleep — not even during the continuity pause (below)
A family of small specialized models serves specific structural roles, all of them reached through one model gate — see §4.
The platform's protocol is TWP — typed word protocol. Its shape:
| element | what it is |
|---|---|
| verb | every message is a named, typed action (query, ingest, route, rule…) — the verb determines the meaning and the authority required |
| authority in frame | identity and authorization ride on every message; a message without a valid issuer is refused by structure, not by policy |
| request / response | verbs are request/response with typed results; refusal is itself a typed, signed response — silence is never a protocol state |
| queues of words | transport is a queue of typed words; ordering and delivery semantics are part of the type |
| no free-form payloads | there is no generic byte channel to exploit; every field is expected and typed |
The protocol is why “network security” in Tartarus is mostly structural: the confused-deputy, injection and replay classes attack shapes that do not exist here.
| model | role | responsibility |
|---|---|---|
| the gatekeeper | the root of identity | the sole issuer of machine identity, and the behavioral classifier at the one door — microseconds per check; the crown the whole system protects |
| the shield | the rules | network-rule suggestion at the interface; watches every communication shape and proposes the rules the fabric enforces — and a rule may only be tightened, never loosened; never sleeps |
| the voice | the translator | words ⇄ structure: natural language into the platform's typed grammar and back; grammar-locked output |
| the smith | the forge | structure → code: generates programs (multi-language) from the database's structural form |
| the shaper | the dialect brain | translates between programming-language dialects at the structural level; the fastest and smallest of the family, and honest about its consistency gap |
| the court | the judges | three judges, one watch each — over the wire and integrity reports, over identity and supervision, over the execution and spawn layer — a verdict of two of three, with a final appeal when the bench splits, ruled on record |
| the immune assistant | the court's helper | the court's hundred-handed helper: cross-checks everything, verifies anomalies in context, opens cases, watches the watchers — and never votes |
| the execution power | not a model | the court's execution power; the only entity that may destroy a condemned power, and only on a ruling |
| the model gate | the supervisor | routes, selects and scales every model request; no model is reached directly — the model layer is governed, not called |
Every model has a measured scoreboard (accuracy, latency, basis of every number) — the family is qualified by measurement, not by claim.
The worst event a platform can endure is the compromise of its own root. Tartarus treats it as a controlled pause:
a judge rules; the execution power acts — the compromised root dies with its keys burned
an independent time authority declares the cut, ten seconds ahead — the window turns a chaotic crash into an ordered shutdown
at the tick, the platform's kernels park: schedules and timers stop together, so nothing expires mid-crisis and no retry can fire
at the window the court births a new root and rotates keys with nothing in flight — the one clean moment to rotate
every domain re-anchors to the new authority at an auditable boundary
work resumes exactly where it stopped — zero retries, zero deadlines, user transcripts intact
The platform's worst day looks to its users like a ten-second pause. We call the state Lethargos; the user sees one honest sentence: “Tartarus is in Lethargos.”
Tartarus does not bolt defenses onto a general system; whole attack classes are absent by construction, and the rest is prevented by layered mechanisms:
| mechanism | what it prevents |
|---|---|
| typed verbs only (no free-form payloads) | injection, protocol confusion, fuzz-shaped memory attacks — there is no generic channel to exploit |
| authority in every frame | spoofing and confused-deputy: an unissued message is refused by structure |
| the name IS the boundary | lateral movement: nothing self-names, and authority never crosses a name it was not issued for |
| domain isolation | data exfiltration between components: cross-domain traffic is narrow, typed control signalling only |
| supervision domains rebuilt from config | drift inside a domain: each domain's data plane is rebuilt from its configuration and never mutated in place; its rows are written only by its own supervisor |
| rules that only tighten (netrules) | a defense quietly weakened: a rule may be added or superseded, never loosened — and a weakening attempt is itself treated as an attack signal |
| no TCP, one narrow data path | the entire legacy network attack surface — port scans, stream hijacks, generic remote services |
| passive verification | scan-shaped monitoring itself becoming an attack vector: the system verifies by reading state; sweep-shaped traffic is treated as an anomaly |
| paired watchers on every machine (integrity + supervision) | silent tampering: every machine watches itself and its neighbours; images without watchers fail to build |
| infrastructure enforced below the OS | configuration drift and privilege escalation from inside a machine: the rules live below what the machine can argue with |
| append-only mathematical record | cover-ups and forensic ambiguity: every meaningful action is provable or deniable — by mathematics, not trust |
| governed model access (the supervisor layer) | unmediated AI: no model is reached directly; every request routes through governance |
| one execution power, only on a ruling | rogue kills and vigilante automation: authority to destroy exists exactly once, and only a court ruling arms it |
| LETHARGOS continuity (§8) | the worst case — root compromise — escalating into corruption, key theft, or downtime |
Every number below is produced by a named harness on held-out data; targets and estimates are labeled as such.
| unit | what it does | the number |
|---|---|---|
| the gatekeeper | behavioral classification at the one door | 99.99% detection, 0 false positives (held-out) at 3.6 µs per check — a 5,456 B artifact against GB-class ML comparables |
| the shield | network-rule suggestion at the interface | 99.45% exact match (+12.6 pp over its own baseline); p50 10.2 ms on one CPU core — vs 0.28–1.3 s typical for API model first-token |
| the voice | prose → typed structure, grammar-locked | 14/14 valid outputs, 601 ms mean — a same-harness market baseline scored 9/14 in 21.5 s: 36× faster, 100% valid vs 64% |
| the shaper | structural translation between languages | 15.8× faster and 74× smaller than its own teacher model, matching it on exactness |
| the smith | structure → code | C behavior-match lifted 0.375 → 0.79 on its proven corpus (held-out instrument, measured); the 1.00 target honestly unreached |
| the court | judgment over the fabric | each judge reads 100% of held-out dockets with 0 false positives — re-scored on CPU from the shipped bytes, never retrained |
| the platform | the code database + fabric | ~60 components (56 workspace crates) · ~5,500 Rust test functions · ~24 named machines · zero TCP anywhere — counted October 2026 |
The culture matters as much as the numbers: the platform's documentation labels every figure measured / target / published — and the model campaign refuses to report an unmeasured result at all.
Tartarus is reached through the client, a native macOS application — installed software, not a website: no browser, no JavaScript. It is the single human surface: the SQL shim, the SDKs and ingestion are human edges beside it, and every line out of them becomes typed numbers. The client speaks only the platform SDK; it presents the code database, the analysis surface (repository → brick graph → explanation → “build me a clone”), the lease queue, artifacts, the model family, and the governed agent workflows. Design law: every screen is built to a fixed specification and judged against it.
Teams that engineer software with AI at industrial depth: structural understanding of large codebases, repository conversion into first-class engine content, and multi-agent pipelines under governance and proof. Vavelio serves a referral-only client list; the platform is not a self-serve commodity.
Tartarus alpha opens in 15 days (November 2026) to referred seats: the native client, the code database and analysis surface, and the governed agent network. Continuity (LETHARGOS) enters the platform in the cycle following the alpha.
Governed by the Constitution and Laws — the order of power, and the limit on each.