Orreth
A kernel for fleets of agents. Identity, memory, rails, meter, gate, watches and levers are held by the kernel; policy is held by humans; an intention is the unit of control. Everything a body does lands on one signed record, and a person can always stop what the machine manages.
This is not a dashboard. THE PANEL is the one viewport: geometry is what is declared, light is what is happening, colour is who did it — amber a person, cyan a body, violet the kernel, red a watch or a hold. The kernel's six organs across the top, the firmware rails lighting as facts pass, every door with its p50/p95, the crew at their stations, the shelf's tools with their consequence on the border, and the running board where every row is a door. It follows your theme: the night glass here in dark mode, the Daylight Glass in light. A photograph of a kernel that really ran stands at demo.orreth.ai.
Why a Kernel
The systemic problem in agent fleets today is entropy. Every agent brings its own identity story, its own memory, its own way of calling a tool, its own idea of what it may do and what it costs; put twenty of them on one problem and nobody can say who did what, under which law, for how much, or how to stop it. Frameworks add loops; they do not remove the entropy.
An operating system removed that entropy for programs by taking the rigid parts away from them — processes, files, permissions, the clock — and holding them in one place under one law. Orreth does that for agents. Because the control is rigid, the experience can be fluid: one chat to every body, and THE PANEL — one live drawing of the world. Humans sit outside and apply control; the kernel applies ontology to the running state so the world stays reproducible, trusted, understood, and evolving.
What the Kernel Holds
The rigid control, taken away from every agent and held in one place — all of it running today, on one laptop
Identity
A keypair is a self, and a self survives the process. A body re-joins as the same self, every life; a person sits with a seat the kernel minted after a proof. Nothing acts anonymously, ever.
Memory
One signed, append-only record on the ground; corrections are siblings, never overwrites; a purge is a governed act that leaves a hash, never words. Every view is a projection over that one truth.
Rails
Every ask, reply, fact and tool call rides the same envelope over the same rails — Postgres · RabbitMQ · Kafka — poison parked with its evidence, nothing lost, everything replayable.
Meter
Every thought a body has goes through one gateway under the body's own key, and lands in dollars beside the work. Nothing thinks off-meter. Cost is a fact on the record, not a report you run later.
Gate
A body joins through a five-status desk; a person's word is the only thing that admits it; scopes only narrow; refusal wears one face, so a prober learns nothing from how it was refused.
Watches & Levers
The kernel watches its own doors, benches, leases and outbox; every remedy is a lever a person can see; a routine one the kernel pulls itself and says so; a consequential one holds until a person says yes.
The Glass
One page, served by the kernel itself — the panel, the tour, the monitor and the one chat; every render a governed door, never a side channel
The Tour
The Monitor
The One Chat
The Rules This World Is Built Under
Thirteen are in the covenant every model coding here holds to — these are the ones a newcomer feels first
The Crew
The kernel seats every body as a process it governs. Residents have a name and a persona; firmware has a function and no persona. A body that dies comes back as the same self; one that dies three times in five minutes is parked and said. There is no body in this world that a person didn't admit.
reads and recalls what this world knows; acquires, marks, seals and purges on the record
repeats your words back, no mind — the honest yardstick for the ask road
plans the next step; reads a red watch's dossier and names a lever from the catalogue
says what holds and what doesn't, before a plan moves
grades the crew's work — never its own; the seat the learning loops are designed to ride on
the Master Mind In the Loop — has read the canon and says what a change touches
keeps the shelf: nine built-in tools and the MCP servers, each a door with a declared consequence
keeps the stable of minds: pinned deals, health, drift and end-of-life — proposes, never acts alone
answers about the crew itself — every body in this world, both sides
reads the Operating State — pulse, peers, the stable, health, rails, bodies, asks, watches
The Miss, and the Kernel Built in Its Place
The first architecture is never called a failure: it worked. It was built under the wrong growth context.
Orreth's first architecture — seventy-three design dives, the Living Brain, the Console, the demo reel, an earlier plane and its Python sim — was a working universe: agents with permanent identities, a signed memory, a living console you could fly through. On 2026-09-14 it was halted, because the instruments were saying what the demos weren't: it was architected to get slower as it got more complex. One user, one world, and a room that took seventeen seconds to paint at the tail. It is kept whole, never deleted, at the tag main-v0.72-old-world.
Two mistakes, named plainly. We chased the interface — every good idea got a room in the console, and the interface is where you feel governance, not where it lives. We made everything a small agent — fine at five, a problem at fifty, a wall at five hundred, because the governance of all those small minds becomes the load. What we learned, in four lines: intent drives action, so intention is the unit a human should control; to control intention you apply control, and the more points of control the kernel holds, the less entropy the fleet can generate; reproducibility is a kernel job, not an agent job; and the human must always be able to stop what the machine manages. So we stopped, and we built one — in Rust, with a Python reference that pins every law as a fixture both kernels must pass unchanged. The whole story is the lead article of the series below.
The Line — What Is Built, What Is Owed
The build plan's rows, said the way the honest boundary says them. A claim not on that page is a claim we do not make.
The Human Profile
What this ground knows about you, in your own words — read from the panel's sill.
The Tool Door
Every tool a door with a declared consequence: plain, routine, consequential, grave — the border tells you which.
The Gate — the seat and the join desk
A person proves a TOTP code and receives a capability token the kernel signed; the first prover on an empty ground is its owner. A stranger's body walks a five-status desk to a root-chained lease with a fuel clause in dollars.
The Remediation Rail
A red watch opens a forensic dossier, a firmware planner names a lever, the kernel pulls the routine ones itself and holds the consequential ones for a person; the outcome is attributed on the record.
The Re-base — main replaced at 0.1.0, and THE PANEL
The kernel replaced the old world on main; the one viewport landed; the image, the book and the photograph of the panel followed the next day.
The Machine Road
Strangers' bodies doing real work through the desk: a leased body is decorative until the machine ask road lands.
The Learning Loops and the Long Objective
The grader's signed verdicts, the lessons digest, the two-speed rule and the thousand-hop objective — written in the canon and in the articles; owed on the line.
The standing register of what is proven, partial or parked — with the evidence named — is the honest boundary. Also owed there today: an amd64 image (the published one is linux/arm64), and cells across machines.
Architecture — One Kernel, One Law
PEOPLE ─── policy · a seat proven by a code · the interlock · the forensic turn
│ one chat to every body · THE PANEL: geometry = declared · light = happening · colour = who
▼
┌──────────────────────────── orrethd · the kernel (Rust, :4600) ─────────────────────────────┐
│ IDENTITY a keypair is a self · a self survives the process · a seat minted after a proof │
│ MEMORY one signed append-only record · corrections are siblings · a purge leaves a hash │
│ RAILS one envelope · Postgres · RabbitMQ · Kafka · poison parked with its evidence │
│ METER every thought through one gateway under the body's own key · lands in dollars │
│ GATE a five-status desk · a person's word admits · scopes only narrow · one refusal │
│ WATCHES doors · benches · leases · outbox → a dossier → a lever → an attributed outcome │
└──────────────┬───────────────────────────────────────────────────────┬──────────────────────┘
│ seats every body as a process it governs │ the reference (Python, :4601)
▼ │ pins every law as a fixture
THE CREW residents: the librarian · echo │ both kernels pass unchanged
firmware: planner · critic · grader · MITL · ▼
toolkeeper · stablekeeper · crew · monitor 26 fixtures · 730 Rust cases
│
▼
THE GROUND forty tables, one writer ever · THE FEED thirty-three topics · every door p50/p95
CELLS a second universe one command away — its own ground, benches, topics, self, seeds —
sealed from every other; two cells speak only over a signed seamTechnology Stack
The Kernel
The Ground & Rails
Identity & the Gate
The Meter
Cells
Watches & Levers
The Glass
The Box
The Lineage
Everything else on this site was practice for Orreth — and Orreth's first world was practice for the kernel
CortexObserver proved a governed AI workforce commanded in plain English. ProblemSolver's Thinker–Planner–Critic–Judge pipeline became the ancestor of the crew's planner, critic and grader. MCPFarm's centralized tool governance became the shelf — where every tool is a door with a declared consequence. Each platform answered a question; together they raised the one the kernel answers: what must one program hold, under one law, so that a fleet of agents stays reproducible, trusted, understood, and evolving?
Orreth is that program — designed in public-methodology dives with every decision locked on a ledger, built twice (a Python reference and a Rust kernel held to the same fixtures), and served three ways: the book at docs.orreth.ai, the panel's photograph at demo.orreth.ai, and the source at github.com/iotlodge/orreth. The difference in one line: CortexObserver ran impressive flows; the kernel is what makes a fleet of them survivable.
Read the Series
Orreth's ideas, one essay at a time — published here first. The kernel set opens with the lead article and runs four deep; the earlier ten are the first world's ideas, several of which the kernel carried forward.