DEV Community: Jonathan Barth

Agents Are Firmware

Jonathan Barth — Thu, 03 Sep 2026 17:59:32 +0000

A kernel, resident firmware that governs, purpose-built capabilities atop — and one razor separating them.

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. I'm
exploring senior architecture and applied-AI leadership roles; if this
kind of thinking is useful to your team, my door is open.

Originally published at jsbarth.com in August 2026. Since then the whole estate has gone public and runnable: the code — github.com/iotlodge/orreth (371 conformance tests) · the book — docs.orreth.ai (every tutorial walked before it shipped) · the live demo — demo.orreth.ai · pip install orreth-agent · docker pull ghcr.io/iotlodge/orrethd.

The End of the Context Window

Jonathan Barth — Thu, 03 Sep 2026 17:52:26 +0000

The most expensive apology in software — the fourth look at Orreth.

The context window is the most expensive apology in software.

Every large language model is amnesiac by construction: brilliant for one request, blank at the next. The context window is the industry's apology for that — a clipboard we stuff with everything the mind might need, every single time we wake it. And because the apology never fixes the amnesia, the apology just grows. Eight thousand tokens became two hundred thousand became millions, every vendor racing to sell you a bigger clipboard at clipboard-squared prices, while the failure mode stays exactly where it was: the model still remembers nothing. You're not buying memory. You're buying rent — paid per request, forever, on a world your mind can't keep.

Here's the tell that the whole framing is wrong: ask what's in those millions of tokens. It's your world — the org chart, the history, the decisions, the documents — flattened into prose and re-shipped to a stateless mind on every call, hoping attention finds the needle. We are paying quadratic prices to remind a genius who it works for.

So invert it. Stop carrying the world to the mind. Keep the world outside the mind — structured, permanent, owned — and hand each thought only the slice it has earned.

The image above is that inversion drawn honestly, and it's worth reading slowly. The lanes are one enterprise's memory across all of time — every actor an identity, every memory signed, nothing unattributable. The lanes have horizons: a field team keeps its raw detail for ninety days, an ecosystem for a year, and what matters climbs — pruned, distilled, promoted — to an apex lane that holds the distilled story of everything, forever. Memory here doesn't expire; it changes resolution. The deep past is an impression with receipts — and because every distillation carries a signed chain to what it came from, the impression can be re-sharpened from source when a question needs the moment exact. Now find the small orange rectangle in the corner. That is a context window, drawn to scale against the world it's apologizing for. Everything to its left: forgotten by design.

Then the part the diagram makes almost casual, which is the entire economic argument: the dotted line. One question, asked at a working seat near the bottom, rides up the block — through the field's ninety days, the ecosystem's year, the apex's forever — and comes back answered from all of time. The question travels to the memory. The memory never travels to the question. Nobody re-reads the corporate history into a prompt; the substrate is queried like the database it actually is, under authorization, on a budget, with every answer carrying its provenance.

And what travels back down is the radical part, because it's almost nothing. When this universe fans work out to its agents, each seat receives exactly one intention: a single sentence of intent, a budget slice, and citation references — never the whole plan, never its siblings' work, never the reasoning history of the layer above. That's not frugality for its own sake. Small context is governance: a seat that only knows its slice can only leak its slice, can only be prompt-poisoned about its slice, and can be audited against its slice. As of this week, that auditability is a thing you can click: open any finished objective in the glass, walk to any seat, and read WHAT RODE DOWN — everything that agent was given, and therefore everything it wasn't. The seat that did the best-audited thinking in the whole universe ran on a few hundred tokens — while standing on an institution of thousands of signed memories it could query but never hoard.

The working memory in between — the scratch, the drafts, the wandering — evaporates when the thought completes, by design. What persists is the record of thought: what was asked, what it cost, what came back, who judged it. Institutions don't archive their employees' scratch paper either. They archive decisions, with signatures.

Three honest boundaries, because "the end of" earns skepticism. First, this trades a window problem for a retrieval problem — a porthole to the ocean still needs navigation, and ranking what matters out of years of memory is a real discipline (ours has a roadmap: hybrid meaning-search over the signed log; today's retrieval is deterministic and budgeted, and refuses in exactly one shape so a prober learns nothing). Second, distillation is lossy on purpose — that's what affordable forever costs — so the system keeps sealed samples of raw history to score its own summaries against, and provenance chains to re-derive any conclusion from source. Third, none of this makes long-context models useless. It makes them a choice — reach for a wide window when a single document genuinely needs one — instead of a mortgage you pay on every request because your architecture has nowhere else to keep the world.

If you run the numbers, run these: what fraction of your prompt spend is the same organizational context, re-sent? What does that curve do as your agent count grows? A context window is rent that rises with ambition. A memory substrate is a mortgage that ends — you pay to keep a minute once, and every future question amortizes it.

In the first article I argued machines need memory that doesn't fade. The second gave that memory an organization; the third gave you a window to stand at and watch a whole world's minute. This is the quiet consequence underneath all three: once the world itself remembers — signed, tiered, distilled, navigable — the clipboard stops being load-bearing. The context window doesn't lose the race to something bigger. It ends the way portholes end: you walked out onto the deck.

The mechanism in this piece is running code, not roadmap: the tiered horizons, the distillation with signed provenance, the one-sentence intention contract, and — as of this week — the walk where you click any seat and read exactly what it knew. Stand at the window: https://demo.orreth.ai. More soon: what a world like this secretes as a byproduct (your ML team will want to sit down), and what it does back to the agents who live in it.

Originally published at jsbarth.com in July 2026. Since then the whole estate has gone public and runnable: the code — github.com/iotlodge/orreth (371 conformance tests) · the book — docs.orreth.ai (every tutorial walked before it shipped) · the live demo — demo.orreth.ai · pip install orreth-agent · docker pull ghcr.io/iotlodge/orrethd.

This build is my résumé — I'm exploring senior agentic-infrastructure / architecture roles: jsbarth.com.