Every agent in your fleet is either learning or decaying. The real question is whether its teacher is governed. How we designed near-live improvement for an army of agents — without touching a model weight, and without opening the door that raw feedback opens.
Here's a quiet truth about every agent deployment I've seen: the day you ship an agent is the best it will ever be — unless something teaches it. The world changes under it. The model behind it drifts (sometimes with no release note — we've all read those threads). The corpus grows. The users' questions evolve. A static agent doesn't stay good; it stays still, and still is a slow way of getting worse.
The industry's answers don't scale to what's coming. Retraining is slow, expensive, and opaque — and most enterprises will never fine-tune anything. Hand-tuning prompts works for five agents and collapses at five hundred. And the tempting shortcut — pipe user feedback straight into the agent's behavior — is a security hole wearing a UX costume. I'll spend the entire next article on that hole.
So we designed a third way — and it turns out the kernel I described in the last piece, the one that already holds every agent's identity, record, rails and meter, makes it almost free.
Three loops, not one. Loop one is self-critique in flight: the agent's own graph checks its work before answering — useful, but it grades its own homework. Loop two is the offline harness: scheduled A/B regression tests against golden sets, at the template level — the thing that catches a model provider silently changing behavior under you (yes, that happens; test harnesses are not optional at fleet scale). Both loops exist in mature shops.
The third loop is the new one: near-live graded experience, folded back into the agent's working knowledge.
The mechanism, in plain words. Today, in our kernel, every reply an agent produces is already a signed event on a rail, and every agent's memory already distills into digests it packs into its context. The loop is the piece we're building on top of that, and it's designed like this. A grader — not a script, a firmware resident: an agent with its own identity, no persona, a job, its own credentials, its own metered budget — consumes those reply events, grades the work against its rubric, and commits a signed verdict: thumb up or down, with the feedback that explains it. Verdicts distill, continuously, into a per-agent lessons digest — a short, current summary of what the field has been telling this agent about its own work. The next time the agent picks up an ask, those lessons are simply part of its packed context.
That's the whole trick. The agent learns in seconds, not training cycles. In context, not weights. And because it's the kernel underneath — and every graded act already hangs under the human intention that authorized it — the loop inherits, by construction, properties that matter enormously at enterprise scale:
- It's visible. You can open the lessons digest and read, in plain words, exactly what your agent currently believes about how to do its job better.
- It's auditable. Every lesson traces to signed verdicts, and every verdict traces to the specific graded work. "Why did the agent start doing it that way?" is a query, not an archaeology project.
- It's instantly revocable. Unassign the grader and the lessons stop packing. There is no un-fine-tuning; there is un-assigning.
- It's rebuildable. Burn the digest and it rebuilds from the signed log — because in this architecture, every derived view is a projection over one truth, never a second truth.
The two-speed rule keeps it honest. Fast lane: lessons ride the context pack — ephemeral, current, revocable. Slow lane: when a lesson deserves permanence — a persona change, a prompt change, a template change — it does not just happen. It goes through a versioned change gate and must pass the offline harness before promotion. We hold a law in the canon that compresses this: learned behavior is never silent. Nothing your agents absorb from experience becomes durable behavior without a versioned, tested, human-visible artifact.
And then the part that made me sit back. Sub-agents — the short-lived workers an agent spawns for a task — don't carry lessons; they're gone in minutes. But their creator absorbs the graded outcomes of everything it spawned. Point that at your agent factory and the inventory itself starts to evolve: templates improve from field grades, each improvement a versioned, harness-proven sibling of the last, each promotion carrying its evidence. The factory learns. Not mystically — bureaucratically, with receipts. At a thousand agents, that's the difference between a fleet you tune and a fleet that compounds.
One demo tells the whole story, and it's a row in our build plan, not a slide: an agent answers; the grader's verdict lands on the live feed seconds later; the agent's next answer is visibly better — and says why. "Feedback taught me…" — on the record, with the signature chain behind the sentence.
Everything becomes agents. The winners won't be the ones with the smartest single agent — they'll be the ones whose ten thousand ordinary agents got a little better every day, provably, without anyone touching a weight or losing a night's sleep about what, exactly, the fleet just learned.
The obvious objection is the important one: a channel that changes your agents' behavior is a weapon if the wrong hands reach it. That objection is correct — and it's why the next article exists.
Orreth is an agentic architecture governance kernel, built in the open. I'm exploring senior strategy and architecture roles in agentic infrastructure — say hello.
Next in the series: Feedback Is an Attack Surface.