Every self-improving AI system must address a fundamental question: as it gains experience from solving tasks, what should persist and improve over time? An agent fails a task, and there are many ways to improve it: tune its prompt (GEPA, OpenEvolve), rewrite the harness around it (Meta-Harness), let it distill its own successful runs into a skill library (Voyager, SkillWeaver), let it rewrite its own code (DGM), or even rewrite the procedure it uses to rewrite itself (HyperAgents).
Each of these agent-centric systems addresses the question in the same high-level approach: the agent itself is what should persist and carry the improvement. That answer can be very costly. One persistent agent must absorb every lesson it ever learns, and those lessons are often task-specific, redundant, or contradictory. Conflicting updates dilute useful behavior, and each new adaptation risks breaking what already worked.
We propose an alternative approach, which we call knowledge-centric self-improvement. The agent stays generic, stateless, and disposable, so no update can break what already worked; improvement accumulates in the knowledge that agents curate. This knowledge can be easily vetted: claims are debated in a forum, contradictions are locally scoped rather than averaged away, and only generalizable lessons survive distillation.
| Approach | Improving substrate | Improving mechanism | Agent-agnostic |
|---|---|---|---|
| GEPAprompt optimization | The agent’s prompt | Optimized against a task split | ✗ |
| Meta-Harnessharness search | The agent’s scaffold | Searched over designs | ✗ |
| Voyagerskill libraries | The agent’s skills | Agent-side abstraction of its own runs | ✗ |
| MemGPTmemory architectures | The agent’s memory | Stored and retrieved | ✗ |
| DGM, HyperAgentsself-improving agents | The agent’s codebase, meta-agent included | Self-modified over iterations | ✗ |
| Oursknowledge-centric | A separate, shared knowledge base | Adjudicated across agents, then distilled | ✓ |
Each row is a representative method. The agent-centric approaches improve something that lives in the agent; ours improves a separate, shared knowledge base. The last column is the variable we hold fixed: in our setup the solver never changes, so any improvement must come from the knowledge base.
We hypothesize that knowledge-centric self-improvement can be significantly more cost-effective than agent-centric approaches. To test this hypothesis, we employ a setup which uses a simple knowledge curation protocol as the only source of self-improvement, and compare against agent-centric approaches.
Knowledge curation runs in three stages of increasing abstraction (see animation below). Each task has its own thread, the task-level forum, where agents post what they found, and reply to one another. In the cross-task forum, agents then compare findings across tasks and ask which claims are generalizable lessons. For each new task, a final distillation pass decides what knowledge is passed to new agents. This step selects claims that are actionable, evidence-grounded, and properly scoped. Note that this step is task-dependent.
The agents themselves carry nothing between tasks. Every agent is a fresh, stateless solver whose lifecycle is querying the shared knowledge base, attempting a task, and contributing back to the knowledge base. For simplicity, we run one batch of agents (one per unsolved task) at a time, making progress easier to measure and compare with prior agent-centric baselines.
The knowledge curation protocol shown as a loop of five steps: Seed, Attempt, Task-level forum, Cross-task forum, and Distillation. A stateless agent seeds from the shared knowledge base, attempts one task, and its evidence is curated through a task-level forum and a cross-task forum. At Distillation the surviving insight is written back to the base, which sits at the center as a living store of insights, revised with each pass while the agents stay fixed. Use the step tabs to jump to any step; play, pause, or change speed.
Agents turn raw traces into local evidence (what helped, what misled) scoped to the task it came from.
Agents discuss what transfers across tasks. Each claim is grounded in a primitive; replies agree, disagree, refine, or synthesize. Disagreement counts as evidence, not noise.
Surviving claims are distilled into typed bundles and written back to the base; later agents seed from them.
The knowledge base is a plain-text artifact: a set of typed claims including reusable strategies, falsified hypotheses, and scoped pitfalls, with each carrying the evidence that produced it. Each entry is concrete enough to act on, names the conditions under which it applies, and gets revised or retired as new evidence arrives.
Below is a real Terminal-Bench 2 run. Pick a generation on the timeline and read one lesson as it climbs the three stages from the diagram above: task-level evidence anchored in specific traces, the cross-task pattern that survived discussion, and the distilled guidance handed to the next generation. Two things to note with each step: claims get sharper and more tightly scoped, and the cumulative solve rate in the corner climbs as the base grows.
That single lesson is one thread in a much larger fabric. Zoom out, and the entire base appears at once — every claim placed by semantic similarity, gathered into the topics the agents kept returning to.
The evaluation spans five benchmarks: coding (Polyglot, SWE-bench Pro), abstract reasoning (ARC-AGI-1, ARC-AGI-2), and terminal skills (Terminal-Bench 2). Each run improves for 10 generations over a fixed task pool, and our numbers are means over three seeds. Every number is reproducible with the open-source KSI framework; see the benchmarks guide for datasets and run presets.
The comparisons below hold the LLM at Haiku 4.5 to match the baselines, so the only difference is where improvement accumulates.
| Method | ARC-AGI-1 | ARC-AGI-2 | ||
|---|---|---|---|---|
| Solve ↑ | Cost ↓ | Solve ↑ | Cost ↓ | |
| HyperAgents (Haiku 4.5) | 70% | $234 | 60% | $188 |
| Ours (Haiku 4.5) | 86.7%±4.2 | $76±16 | 82.7%±6.1 | $80±1 |
Abstract reasoning over 10 generations. Ours is mean over three seeds; baselines are single runs rerun under our evaluation protocol. DGM targets only coding, so it does not appear here.
| Method | Polyglot | SWE-bench Pro | ||
|---|---|---|---|---|
| Solve ↑ | Cost ↓ | Solve ↑ | Cost ↓ | |
| HyperAgents (Haiku 4.5) | 52% | $190 | 42% | $431 |
| DGM (Haiku 4.5) | 58% | $281 | 54% | $713 |
| Ours (Haiku 4.5) | 68.0%±2.0 | $126±6 | 64.0%±2.0 | $208±19 |
Coding benchmarks under the same protocol: ours is mean over three seeds; DGM and HyperAgents are single reruns.
| Method | Terminal-Bench 2 |
|---|---|
| OpenHands | 13.9% |
| Terminus 2 | 28.3% |
| Mini-SWE-Agent | 29.8% |
| Terminus-KIRA | 33.7% |
| Goose | 35.5% |
| Meta-Harness (Opus 4.6 + Haiku 4.5) | 37.6% |
| Ours (Haiku 4.5) | 43.8%±3.4 |
Terminal-Bench 2 leaderboard scores where available, otherwise from the corresponding papers. Our simple agents reach competitive performance without changing the agent or scaffold: only the shared knowledge improves.
| Method | ARC-AGI-1 | Polyglot |
|---|---|---|
| OpenEvolve | 54% | 46% |
| GEPA | 44% | 36% |
| Ours (Haiku 4.5) | 86.7%±4.2 | 68.0%±2.0 |
Against prompt-optimization methods, with improvement budgets matched to the realized cost of our main runs ($76 on ARC-AGI-1, $126 on Polyglot). Curating a reusable knowledge artifact beats optimizing a reusable solver prompt, a distinct self-improvement axis from the agent-centric baselines above.
The protocol is not tuned to one model family: the tables below run the identical procedure on GPT-5.4-mini.
| LLM | ARC-AGI-1 | ARC-AGI-2 | ||
|---|---|---|---|---|
| Solve ↑ | Cost ↓ | Solve ↑ | Cost ↓ | |
| Haiku 4.5 | 86.7%±4.2 | $76±16 | 82.7%±6.1 | $80±1 |
| GPT-5.4-mini (medium thinking) | 93.3%±7.0 | $16±3 | 90.0%±5.3 | $20±1 |
| LLM | Polyglot | SWE-bench Pro | ||
|---|---|---|---|---|
| Solve ↑ | Cost ↓ | Solve ↑ | Cost ↓ | |
| Haiku 4.5 | 68.0%±2.0 | $126±6 | 64.0%±2.0 | $208±19 |
| GPT-5.4-mini (medium thinking) | 72.7%±2.3 | $56±1 | 70.7%±2.3 | $157±11 |
The same procedure carries unchanged to a different model family (mean over three seeds), and GPT-5.4-mini is both stronger and cheaper on all four benchmarks.
The final question is whether the knowledge base carries standalone value: whether the artifact, separated from the procedure that produced it, still helps on unseen tasks. The donor is the LLM whose run produced the frozen bundle; the recipient is the LLM that consumes it on held-out tasks, zero-shot: no new forum discussion, no recipient-side distillation, only a task-conditioned adapter that turns the bundle into a short memo for the task at hand.
The frozen bundle on the 20 held-out tasks — hard by construction, so absolute rates are low. Rows are recipients; columns are donors. Darker = higher solve rate.
| Recipient \ Donor | None | GPT | Haiku |
|---|---|---|---|
| GPT-5.4-mini (medium thinking) | 8.3%±2.9 | 20.0%±5.0 | 11.7%±2.9 |
| Haiku 4.5 | 3.3%±2.9 | 11.7%±2.9 | 11.7%±2.9 |
| Recipient \ Donor | None | GPT | Haiku |
|---|---|---|---|
| GPT-5.4-mini (medium thinking) | 23.3%±2.9 | 43.3%±2.9 | 38.3%±12.6 |
| Haiku 4.5 | 13.3%±2.9 | 28.3%±2.9 | 23.3%±2.9 |
Every donor–recipient pairing improves on the no-knowledge baseline (mean over three seeds). The GPT-authored bundle is the stronger donor throughout, yet cross-family transfer stays positive in both directions, evidence the bundle carries donor-agnostic structure rather than donor-specific habits. One caveat: the Haiku-to-GPT cell on ARC-AGI-1 carries the largest seed variance (±12.6), so read the cross-family magnitudes as indicative rather than precise.
We believe that there is a huge opportunity in fully exploring the design space of self-improving AI systems. Our work shows that focusing the locus of self-improvement on generalizable curated knowledge can be a very cost-effective approach. More broadly, once the agent no longer needs a persistent identity, the design problem shifts to structuring, reconciling, and synthesizing the collective intelligence that transient workers generate.
This shift from agent-centric optimization to knowledge-centric curation fundamentally changes how AI systems accumulate progress. Because a knowledge base lives outside any single model’s weights or runner, it can be version-controlled, compared and audited by human experts, and shared across different models and agents. This points to a future where the frontier is advanced by building a shared, inspectable substrate of reusable knowledge that makes every future agent smarter.
@misc{wang2026knowledge,
title = {Knowledge-Centric Self-Improvement},
author = {Wang, Xuefei and Yoon, Lauren Hyoseo and Qu, Chengrui and Wang, Amanda Zichang and Sehgal, Atharva and Mazumdar, Eric and Yue, Yisong},
year = {2026},
eprint = {2607.19592},
archivePrefix = {arXiv},
url = {https://arxiv.org/abs/2607.19592}
}The full framework is open source. The KSI repository contains the curation protocol, the agents, and presets for every benchmark on this page; the documentation covers setup, configuration, and how to reproduce each table.