If you can change it in production, it's purpose. If it takes a release, it's firmware — the ninth look at Orreth.
The most useful thing I can tell you about my agent platform is a three-layer sentence:
Purpose-built capabilities run atop a kernel — and between them lives a layer of resident firmware that governs everything.
And there's a razor that keeps the layers honest, which I'll get to. First, the layers, bottom up.
The kernel: what Orreth is
Think operating kernel, not framework. The kernel does the substrate jobs and refuses to do anything else: identity as cryptography (every agent is a keypair that survives the process; joining is a challenge at a door), an append-only log of signed records, gates where consequences wait, and meters no one opts out of. It is purpose-blind by design — nothing at this layer knows what any agent is for.
The residents: the firmware
Here's the layer most agent platforms don't have, and the one that makes the rest trustworthy. The residents are Orreth's embedded organs — long-lived agents that deliver the governance everything else consumes:
- becky keeps identity — she challenges every joiner to prove its key, and only a human's word (or a standing welcome a human once gave) mints a lease.
- ada keeps the stable of minds — which models exist, at what class, under what deal. Every thought meters through her gateway.
- charlotte keeps the tool farm — services probe in, earn their place on live heartbeats, and get caught if their manifest changes under you.
- the librarian keeps knowledge — what's gathered, what's quarantined, what a question may honestly retrieve.
- grace keeps the workshop — she proposes improvements from receipts and never grades her own work.
- vera keeps measurement — the independent judge who, by law, never scores her own floor.
- allen keeps the cloud estate; vigil watches; governance arbitrates drift; the steward prunes what memory learns.
These agents are firmware in the exact embedded-systems sense: they ship with the machine, they implement its laws, and in production you cannot casually edit them. Their words — the prompts and standards they run on — are versioned canon. In dev mode a human can tune them through governed doors. Flip the machine to prod and those doors refuse: a change to resident firmware is a release — versioned, gated, auditable, moving the machine's own version the way firmware updates always have.
The capabilities: the purpose
Atop kernel and firmware sit the capabilities — packaged, purpose-built worlds. This is the layer that answers "what does it actually do?"
My first three are trading desks. Each arrives as a folder of declarations — prompts, a manifest, a declared sixteen-stage pipeline — never a line of platform code. Drop the folder in and the kernel discovers the world at boot, raises its floor, welcomes its specialist at becky's gate, and draws its entire room in the Console blind, from the manifest alone. The desk's specialist, charles, walks the pipeline — four analysts, a bull/bear debate, a trader, three risk voices, a portfolio manager — and writes a morning report I actually read, every stage a signed record. His siblings, charlene on crypto and chad on options, are the same package shape with their own words.
One law was written before any of it: the desk observes and reports; it never executes a trade, never moves money, never holds a credential that could. Capability without custody — the firmware layer enforces the boundary, the capability just lives inside it.
And here is the razor that keeps the whole framework honest:
Capabilities stay editable in prod. Resident firmware does not.
You can open a desk in production and tune its analyst prompts, add a watch, schedule a standing question — through gates, with every change landing as a versioned sibling — because purpose content is the human's domain. But the words that becky or vera run on? In prod, read-only; changing how the machine is governed is a release. If you can change it in prod, it's purpose. If it takes a release, it's firmware. That one test tells you which layer anything belongs to.
The control layer: how humans hold it
All of this surfaces in one human-in-the-loop control layer. Every resident and every capability opens into a compact control room: vitals (lifetime spend, runs, the judge's verdicts), the pipeline as a living graph that pulses as stages land, the words on the shelf, and a schedule tab with a real cron face — type a question, pick weekly at 08:00, approve once, and it repeats until you rest it, which never needs a gate. Asking a capability for work is the human's word: the ask itself welcomes its specialist at the gate. Nothing consequential moves without a human word — and no human word is ever demanded twice for the same trust.
Adaptive, on the record
The reason this earns the word adaptive: the learning obeys the same laws. The kernel grades its own memory — ten questions in my words, asked through the same lane a human uses, scored by vera. First run: 0.375, honest and humbling. But her verdicts are sentences — "the answer fabricates a citation instead of reporting per-desk ratings" — and each sentence named a wound, each wound became a fix, each fix was measured by the next run. Six fixes later, same day: 0.786, with one instructive dip where an over-correction made answers assert and then retract, and the judge scored the untrustworthiness exactly as a human would. That lesson is law now: the record's word is never retracted. The desks learn too — every report grades its own prior call against what the market did, and carries the lesson forward.
Why this framework matters
If you're building agents for an enterprise, the deciding question isn't "which framework?" It's: when you have fifty agents, do you want a platform that knows all fifty — or a kernel whose firmware governs whatever purposes you install on it?
Kernel + resident firmware + purpose-built capabilities gives you the properties that matter at scale: purposes as versioned, auditable packages a domain team can ship and tune — even in prod, through gates; governance no capability can opt out of, because it's delivered by firmware below them; a release discipline for the governing layer itself; and a memory you can measure in your own words on the machine's own record.
Three layers, one razor. That's Orreth — and I suspect it's the shape most "agent platforms" will quietly converge on.
Orreth is my personal lab for agentic infrastructure — identity-first, governed, measured. The spectator demo lives at demo.orreth.ai — as of this week it draws the two kinds of life in two colors: gold for the firmware governing, jade for the capability worlds running atop it. I'm exploring senior architecture and applied-AI leadership roles; if this kind of thinking is useful to your team, my door is open.