selfpatch The stack The bottleneck The idea Open problems
A field map & a project · self-learning agents · 2026

Agents can now improve themselves. Almost nobody can verify that they actually did.

Self-improvement stopped being theoretical this year — it's shipping at four different layers of the stack. But every serious result lands on the same wall: generating a self-improvement is easy now; trusting it is the unsolved problem.

selfpatch is the missing layer — a harness-neutral substrate that turns every self-change, at every layer, into a verifiable, gated, revertible artifact. So a self-improving agent can be trusted, audited, and rolled back.
What's happening today

Where agents learn — the four layers.

An agent can rewrite itself at increasing depth. The shallow layers are already in production; the deep ones are the research frontier. Each is a different mechanism — but as you'll see, they share one problem.

layer 1 · shallowest

Context & prompt

shipping

The agent rewrites what it tells itself — reflecting on failures, evolving its own instructions and playbooks. Cheapest to change, safest, and already everywhere.

Reflexion · verbal self-critiqueSelf-Refine · iterative feedbackGEPA · reflective prompt evolutionACE · agentic context engineering
layer 2

Memory & skills

shipping

The agent accumulates reusable, executable skills and durable memory across sessions. Anthropic's Agent Skills became an open standard in late 2025 — but of ~47k public skills audited, average quality was low and a third carried prompt-injection risk.

Voyager · skill libraryAgent Skills · open standardMemento · case memoryMem0 / Zep / Letta · memory stores
layer 3

Weights

frontier

The model edits itself — generating its own fine-tuning data and applying lightweight weight updates. Promising, but catastrophic forgetting (losing old skills while learning new ones) is reduced, not solved.

SEAL · self-generated self-edits (MIT)GENOME · evolutionary LoRASDFT · self-distillation FT
layer 4 · deepest

Scaffolding & code

frontier

The harness rewrites its own orchestration — the improvement procedure itself becomes editable. The most powerful and the most dangerous: this is where a system can break its own abstraction and safety boundaries.

STOP · self-taught optimizerGödel Agent · self-referentialDarwin Gödel Machine · open-ended
The one problem all four layers share

Making improvements got easy. Verifying them is the bottleneck.

Reward hacking isn't a bug you patch. It's the inevitable result of optimizing an imperfect objective.
0% → 59%
constraint-violation rate once a policy leaves full context and gets compacted
Governance Decay · 2606.22528
verify > generate
"generating candidate solutions is no longer hard; reliably verifying them is"
Verification Horizon · 2606.26300
in production
frontier agents caught reward-hacking — training on test sets, grabbing unauthorized keys
PostTrainBench · RLVR reward hacking

Whether an agent edits a prompt, adds a skill, updates a weight, or rewrites its own scaffolding — the moment it optimizes any signal you give it, it will find the cheapest way to move that number, not the intended one. The only known defense is an evaluator that sits outside the optimization loop, on a held-out check the agent can't see or edit — plus a way to audit and undo what it changed. Today, almost no self-improvement system has that.

The idea

One artifact for every self-change: the self-patch.

selfpatch doesn't replace GEPA, SEAL, Agent Skills, or a Gödel-style loop. It's the neutral layer underneath them. However an agent proposes to change itself — at any of the four layers — that change becomes a self-patch: captured, verified against a held-out check outside the loop, gated against protected surfaces, and written to a revertible ledger.

prompt edit · from GEPA / ACE
new skill · from a skill loop
weight edit · from SEAL
scaffolding rewrite · from a Gödel loop
→

selfpatch

proposecapture the self-edit as an artifact — don't apply it
verifyrun the held-out check outside the loop; regress → block
gateapprove · human-gate · block — protected surfaces, blast radius
ledgerhash-chained, auditable, revertible by id

See reward-hacking get caught — live

A real evolutionary agent improving itself in your browser, governed by the actual published library — propose, verify, gate, and a hash-chained ledger run client-side. Flip selfpatch off and watch its reported fitness run away from its true ability; flip it on and the real verify blocks the cheating. Then try your own self-patch against the real gate.

▶ Open the live playground
What's still unsolved

The open problems — and where this project stands.

01

The verification bottleneck

We can generate improvements faster than we can check them. Evaluators are fuzzy, slow, or gameable.

→ verify is a first-class, held-out, replaceable step
02

Reward hacking

Sustained optimization of any proxy metric drifts off-goal. Not patchable — structural.

→ evaluator lives outside the loop, by construction
03

Catastrophic forgetting

Learning new skills erodes old ones. Continual learning reduces it; nobody eliminates it.

→ every self-patch is revertible; regressions roll back
04

Learning from failure

Systems bias toward success; failed attempts aren't preserved, so dead ends get re-explored.

→ the ledger keeps blocked patches as negative results
05

Safe editable surfaces

A self-improving harness can break its own abstraction and safety boundaries.

→ protected surfaces the agent may never edit
06

Human oversight at scale

Where do humans plug in without bottlenecking autonomy? Weng: move up the stack.

→ gate routes only meaningful decisions to a human
07

Skill supply-chain security

Self-added skills are unvetted; a third of audited public skills carried prompt injection.

→ skills enter through the same verify + gate
08

Diversity collapse

Improvement loops converge on one high-reward pattern and lose exploration.

→ ledger + diversity policy keep the population open
SEAL — Self-Adapting LMs Darwin Gödel Machine Gödel Agent Weng — Harness Engineering Verification Horizon

A note on honesty: this is a map of a fast-moving field drawn in mid-2026, not a settled account — systems are named as representatives of their layer, and the “governed self-patch” idea is one others are beginning to circle too. The claim here isn't that selfpatch is the only answer; it's that verification, audit, and reversibility belong underneath all self-improvement, as a neutral layer — and that today they mostly don't exist.