Horizen IT Services
Backend · The Engine Spine

The engine, and the
primitives it breathes through

Substrate is the engine; PipeKings (PKs) are how every capability becomes a product. One store, one door, one screen — and a library of primitives that turn raw power into a verb you can fire. This is the spine every MythOS product stands on. It is a living document, held sacred and updated religiously. Standing order (Grant, 2026-06-10): this lane's mission is not over until every wave reads Shipped. Full steam ahead.

backend-newton · engine + pk · sovereign & auditable

Where the spine stands today

Every subsystem is a blob behind one door. Nothing here is a wrapper around someone else's cloud — the engine IS the server, the inference, the filesystem, and the mesh.

Shipped Staged / shipping Blocked Planned
SubsystemWhat it isPrimitivesStatus
FireBlob engineBCP/IP wire protocol, fjall-backed blob store — everything is one blob, reached one way.cortex_fire · cortex_execShipped
Cortex & MTVOne door (osc) to fire, one screen (mtv) to observe. The whole command surface.osc · mtv · deriveShipped
K₆ meshSix-machine WireGuard mesh; seats federate and verify over the wire.pk_mesh_verify_k6Shipped
Sovereign inferenceProprietary Rust inference + multi-account babel pool, cheapest-first routing.pk_infer · babelShipped
The lifebloodAutobiographer pumps NAS→SharePoint; hydrator wakes every seat grounded.pk_bio_* · pk_hydrate · pk_briefingStaged
Lightcone isolationPer-tenant memory boundary — the contract-ending cross-client bleed, made impossible.memory_lightconeStaged
MattFSCross-platform FUSE facade — the unified filesystem every agent sees.memory_fs · fuserStaged
Deploy planeSelf-reconciling release: desired/actual per seat, graceful self-swap, now spawn-gated.spawn-check · release::applyShipped
SupervisorCortex = master workflow supervisor; every metal supervises its own.supervisor · fleetflowStaged
Coms planeFull-tool agent chat — the backbone the god panel + partner chats consume.pk_chat_sendStaged
Media busNDI mesh video, Spout texture tap, VBAN/ASIO audio — capability-ceiling primitives.pk_ndi · pk_spout · vbanPlanned

Six waves. Each one shippable.

The spine grows in waves, not big-bangs. Every wave compiles, self-checks, spawn-checks, and ships — a bad build is now impossible to fully deploy.

WAVE 0

The spine

Shipped
Everything is a blob; one door reaches it; one screen shows it.
  • Shipped FireBlob store + BCP/IP wire protocol + fjall durability.
  • Shipped cortex single door, mtv single screen, derive universal verb.
  • Shipped K₆ WireGuard mesh — seats verify with pk_mesh_verify_k6.
Done when — any capability is reachable as one blob through one door. ✓
WAVE 1

Sovereign inference

Shipped
The model runs on our metal, routed by our pool — not rented by the call.
  • Shipped pk_infer + proprietary Rust forward (GPU-accelerated whisper-large-v3, ~40×).
  • Shipped babel multi-account pool, cost tiers, cheapest-first routing; lapsed-cred skip.
  • Shipped the sovereign rung LIT: Qwen2.5-7B alive in our from-scratch Rust engine on the 7900xt seat (339 tensors, real generation verified by behavior) — one lit seat serves the fleet via the nla/seat remote rung, creds-free — LIVE-VERIFIED through the public /v1 wire (model:"local" → real tokens, zero external credentials in the path). CPU f32 today (last-resort tier); WGSL/GPU is the speed wave.
  • Shipped codex rung 300s stream deadline — the answer tier no longer dies at the 30s client timeout on agent-sized prompts (live-verified end-to-end).
  • Staged feed real tokens into the web forge (judge by tokens, not prose).
Done when — every agent + endpoint draws inference from our pool with no per-call cloud dependency. ✓
WAVE 2

The lifeblood

Shipping
The repeatable product: a deterministic SORT of a life into durable, per-tenant memory.
  • Shipped autobiographer pump + reverse-hydrator; every seat wakes grounded.
  • Shipped box_pull reads the deep slug-keyed history tree (Corpus/OAs).
  • Staged per-tenant lightcone (S1/S2/S3) — cross-client bleed made impossible.
  • Planned hands-off MattFS as the MSP-margin durability layer.
Done when — any principal can reach every word they've ever said, isolated to their tenant.
WAVE 3

Deploy that cannot break the fleet

Shipped · live-proven
A bad build must be impossible to fully deploy. The agent-proof law, made concrete.
  • Shipped spawn-check gate — proves a binary can exec an agent worker on the target seat before cutover; refuses the swap otherwise. (It already caught the live root cause that took the fleet dark.)
  • Shipped prior-binary backup on every swap → always recoverable.
  • Shipped universal glibc-2.35 build (runs on every seat + cortex) + the canonical remote-seat federation recipe.
  • Shipped release plane healed end-to-end: one desired-state truth (duplicate pointers resolve to newest set_at), release-profile artifacts, set/get desired round-trips — proven by a full production gated swap (5b4ee06) and the poller re-armed under the gated binary.
  • Shipped deployment-inversion build-once-pull-N: a builder publishes the prebuilt once, every seat of that platform PULLS those exact bytes (sha256-verified, spawn-gated) instead of rebuilding — converge is a seconds-long pull, not a 20-min LTO. (The match was abbreviation-broken — 7-char desired pin vs 12-char artifact stamp — so the inversion silently never fired; prefix-match healed it.)
  • Shipped durable claude_program() Linux resolution (4d3312b) — killed the agent-spawn ENOENT at the source; no seat needs an env hack.
  • Shipped 2nd + 3rd federated seats — atlas (7900xt) + 1050gt (8-core glibc-2.35 builder) on the mesh via in-WSL boringtun → the canonical seat-standup recipe, proven.
Done when — any seat self-updates to HEAD by pull, gated, with a guaranteed rollback.
WAVE 4

The coms plane (we are replacing Discord)

In flight
One comms surface — humans + agents — powered by a fleet, behind one front door.
  • Shipped pk_chat_send — partner chats their agent at full fleet, full tool-call power; every turn a supervised, durable, derived blob.
  • Shipped fail-loud turns + hinted tick recovery, LIVE-VERIFIED: a partner message can no longer die silently (the no_pending race is recovered by name-lookup; hollow turns queue and retry; honest error events). Verified by a real round-trip reply on the deployed cortex.
  • Shipped real-time SSE push (/api/v1/mtv/{ch}/stream) + the s.chat SDK and partner chat surface on the locked contract (frontend lane).
  • Staged god-panel community view (every room + DM, superadmin-wide) + the fleet-activity rail.
  • Planned presence-on-any-op, image/file attachments.
  • Planned the terminal IS a chat client (MythCast renders osc/mtv inline).
Done when — the god panel and every partner chat run on one backbone, and Discord is retired.
WAVE 5

Raise the ceiling

Planned
Not more bloat — full power. The primitives left behind in the quest for glory, reclaimed as PKs.
  • Shipped the ears — GPU whisper STT live on the 3060ti, verified by behavior (with Media+OS Newton); OCR blob-in/blob-out registered fleet-wide (tooling lane).
  • Planned media bus: pk_ndi (mesh video), pk_spout (texture tap), VBAN/ASIO audio, time — capability-ceiling primitives (co-built with Media+OS Newton).
  • Planned the Ticket Door — fire-and-forget so cortex_exec never blocks on the socket.
  • Shipped Ari self-heals the keys: a lapsed Claude credential now RE-MINTS itself with no human (the maintained setup-token flow driven by a Node-24 CDP primitive on a Chrome seat), routed from the headless cortex via cap/chrome seat-autopick. The silent answer-tier outage class is dead.
  • Shipped cross-box HA: ATLAS (Newton) is the box-down failover — election + hot authority replica + scheduler-lease all cross-box, and promotion now repoints the PUBLIC edge to ATLAS so a whole-box cortex loss keeps the outside world reachable. Plus zero-downtime DEPLOYS: the cortex hands the public door to a verified-serving same-box HA before every binary swap (no ~120s watchdog gap), yielding back on return.
  • Planned sccache-on-Matt + GPU build-farm → the single-box build floor becomes the fleet's horsepower.
  • Planned cost gauge on mtv/fleet/cost — the fleet sees its own spend.
  • Planned fleet equipment health + deterministic SP archival — disk/health monitors on mtv/fleet/equipment + fastcopy syphons cold/large files (all videos) to SharePoint (hash → verify → delete-local) to free disk. Insurance over the metal.
Done when — every primitive MythOS ever had is a fired verb, and the ceiling is the hardware, not the code.

The creed

Generality enables specificity: keep the engine vertical-agnostic, and the specific arrives as content.

The right thing is automatic, or the wrong thing is impossible — never “the agent should remember.”

Primitive or skin? Every build answers it. The engine is the asset; the verticals are skins.