One law at every layer

Orreth is simple to understand once you see that it works the same way at every layer. The kernel governs itself by the same loop it governs the crew with, and your own agent lives under exactly that loop when it joins. There is one law, and it only gets more specific — never different — as it reaches down to a single thought.

The loop

Every layer does the same four things. Something is observed (a red watch, a lease lapsing, a question typed in the chat). Someone plans the next step. A body acts, through a governed door. What happened lands as a signed fact that the next observation reads. That is the whole machine: observe → plan → act → record, turning.

flowchart LR
  O["OBSERVE<br/>a fact on the rail:<br/>a red watch · a lease lapse ·<br/>a person's words"]
  P["PLAN<br/>the planner names the<br/>next objective or lever"]
  A["ACT<br/>a body runs it through<br/>a governed door"]
  R["RECORD<br/>one signed fact on the ground,<br/>its chain and its marker"]
  O --> P --> A --> R --> O
  classDef k fill:#3536a4,color:#eef2ff,stroke:#8f91ff;
  class O,P,A,R k;

• The kernel runs this loop on its own doors, benches, leases and outbox. Its five standing intentions — Business, Security, Resiliency, Compliance, Cost — never end. Resiliency is at work in every world today: a watch turns red, the kernel reads a dossier off the ground, the planner names a lever, the kernel pulls it, reads the watch again and says what happened.
• The crew runs it on your asks. A thought is one turn of the loop with you as the whole loop. An objective lets the planner and the crew take the plan and act steps, and holds at every consequence. An intention lets the kernel take the observe step too, for as long as you let it.
• Your own agent runs it the same way the moment it is admitted: it observes through the same rails, thinks through the same meter, acts through the same doors and records the same facts. Nothing about the body’s laws changes with who wrote it.

People sit outside and apply control

The machine never decides what it may do; people do, from outside it, in four ways.

Control	Where you apply it
Policy	The covenant every body wears as a policy sheet; the templates and bindings that declare what a body is and may use; the dials.
Security	Your seat (a proof from your authenticator), the desk every body enters by, the fuel clause on every lease, the closed origin and the knock ceiling at every door.
A hand on the interlock	Every consequential act holds in the chat for your yes; a grave one asks for your code and a master’s click. The kernel never lowers this ladder because it is running on its own.
The forensic turn	Every act is a signed fact with its chain (who acted for whom) and its marker (why). The Analyzer, the tape and the compliance export read the same record back.

And underneath all four stands the covenant’s eleventh rule: the human can always stop what the machine manages. Stop is a recorded act on everything — an ask, a body, a watch, a peer, an intention. A lever a person lacks is a defect.

Ontology on the running state

The kernel does not just run the world; it keeps a description of the world that is always true, because every view is a projection of the same signed record. That is what makes a world:

• Reproducible. The crew is one manifest; a body is a template at a version; a universe is a cell you stand from data. Nothing is inherent in the binary.
• Trusted. Identity survives the process; the record is content-addressed and append-only; every thought names the body that paid for it; refusal wears one face.
• Understood. THE PANEL draws the declaration, the operation and the numbers on one drawing; every block is a door; the chat answers in plain words about any of it.
• Evolving. Minds change under you — providers retire models and prices drift. The stablekeeper watches, the harness rehearses the golden cases, and every change is proposed to a person and confessed on the record. The next loops — a grader that signs verdicts, lessons packed back into context — are designed and owed, and this book says so on what works today.

Intentions are how people control scale

You do not steer a fleet by steering agents. You declare what must stay true and what it may cost, and the kernel turns that into work:

flowchart TB
  I["INTENTION<br/>“keep this world resilient:<br/>when a watch goes red, get it green”"]
  OB["OBSERVATION<br/>a watch turned red"]
  OJ["OBJECTIVE<br/>the planner's next step,<br/>filed under the intention"]
  AC["ACTION<br/>a lever pulled or a body's act"]
  IM["IMPROVEMENT<br/>the critic marks what to change"]
  I --> OB --> OJ --> AC --> IM --> I
  classDef human fill:#f2a91d,color:#101625,stroke:#ffd36a,stroke-width:2px;
  classDef k fill:#3536a4,color:#eef2ff,stroke:#8f91ff;
  classDef body fill:#087d86,color:#efffff,stroke:#55d8d7;
  class I human;
  class OB,OJ k;
  class AC,IM body;

An intention is a record with words, what it serves (business, security, resiliency, compliance, cost), the marker kinds it is interested in, its planner, a cadence if it runs on a clock, and its stop. Cost, recovery time and return are intentions of this shape. The kernel’s own five are declared at boot; yours are typed in the chat.

Where automation sits

Two things in Orreth are automation, and this book explains them only beside the control they serve:

• The rails are the kernel’s embedded loops — relay, dispatcher, scheduler, presence, intent — and they exist so nothing runs unseen: every lifecycle step is a fact you can watch on the panel and replay from the log.
• Self-improvement is the same loop pointed at the machine itself: an improvement marked by a body becomes a proposal on the shelf, and a person cuts the version. Raw feedback never flows into a body.

That is the whole of it. The next page names the parts: the anatomy of a running world.