BlackArc20 papers
Self-Improving Agents
Agents that evolve their own prompts, skills, and harnesses from experience.
- Papers
- 20
- Read time
- 6.0h
- Avg length
- 18m
Reflexion: Language Agents with Verbal Reinforcement Learning
Instead of fine-tuning an LLM agent with gradients, let it write itself a paragraph of feedback after each failed attempt and paste that paragraph into the prompt next time — and it learns to solve tasks it couldn't before.
- Read
- 16 min
- Source
- arXiv:2303.11366
GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning
Instead of burning 24,000 RL rollouts to nudge model weights with a scalar reward, GEPA reads the system's own execution traces in plain English, writes itself better prompts, and keeps a Pareto front of "winning" variants — beating GRPO by ~10% on average with up to 35x fewer rollouts.
- Read
- 18 min
- Source
- arXiv:2507.19457
Self-Adapting Language Models
SEAL teaches a language model to write its own study notes for a new fact or task, finetune itself on those notes, and — via reinforcement learning — get better and better at deciding *what notes to write* so the resulting weight update actually sticks.
- Read
- 16 min
- Source
- arXiv:2506.10943
A Survey of Self-Evolving Agents: On Path to Artificial Super Intelligence
A map of the entire emerging field of agents that improve themselves *after deployment*, organized around three clean questions — *what* part of the agent changes, *when* the change happens, and *how* the change is driven — so you can place any technique (Reflexion, STaR, GRPO self-play, Darwin Gödel Machine) on a single grid and reason about which one your product needs.
- Read
- 22 min
- Source
- arXiv:2507.21046
Evo-Harness: Context-to-Harness Skill Compilation for Self-Evolving Agents
After an agent fails a task, squeeze the failure into one or two short, capped, trigger-tagged rules in a markdown file, and inject only the matching rules into the next task — the agent gets better without any retraining.
- Read
- 28 min
- Source
- arXiv:2608.15071
Autogenesis: A Self-Evolving Agent Protocol
Instead of bolting "self-improvement" onto an agent with ad-hoc glue code, treat every mutable piece of the agent (prompts, tools, memory, sub-agents, environment) as a versioned, registered "resource," and run all improvements through a single, auditable five-operator loop — so an agent can rewrite its own prompts and tools at runtime without becoming an unmaintainable, irreversible mess.
- Read
- 22 min
- Source
- arXiv:2604.15034
Continual Harness: Online Adaptation for Self-Improving Foundation Agents
Instead of a human hand-tuning an agent's scaffolding, a second copy of the model reads the agent's own recent play every few hundred steps and rewrites its prompt, sub-agents, skills, and memory on the fly — so the agent bootstraps its own "harness" from a bare interface, mid-run, without ever resetting.
- Read
- 18 min
- Source
- arXiv:2605.09998
Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents
A coding agent that keeps every version of itself it has ever built, repeatedly picks one to rewrite its own source code, and only keeps the rewrite if it actually scores better on real coding benchmarks — turning "self-improving AI" from an unprovable theory into something you can run, measure, and audit.
- Read
- 14 min
- Source
- arXiv:2505.22954
DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines
DSPy replaces hand-written prompt strings with composable, parameterized Python
- Read
- 14 min
- Source
- arXiv:2310.03714
EvoHarness-RL: Learning Self-Evolving Runtime Harness for Long-Horizon LLM Agents
EvoHarness-RL teaches an LLM agent, via reinforcement learning, to decide for itself when to read and write its own external memory — splitting that memory into "what's true right now," "what have I done," and "what have I learned before" — instead of hard-coding that logic in prompts.
- Read
- 14 min
- Source
- arXiv:2608.05446
HyperAgents: Self-Referential Self-Improving Agents
Instead of an agent that just learns to do a task better, this is an agent that can rewrite *the part of itself that decides how to rewrite itself* — so it improves not only its answers but its whole method of getting better, and that meta-skill turns out to transfer across totally different domains.
- Read
- 18 min
- Source
- arXiv:2603.19461
Meta^n: Recursive Self-Improvement through Emergent Depth
Freeze the meta-operation completely and recurse on its *input* instead — each
- Read
- 13 min
- Source
- arXiv:2608.24735
Prime Agent: A Self-Improving RLM Harness
Give a model a persistent Python REPL per session, a way to fire off recursive sub-agents without blocking on their reply, and a versioned scratch-space it can rewrite mid-run — and the *same* model's measured capability jumps, because the harness stops being the bottleneck: on ARC-AGI-3 this alone takes one model from 30% to 95.5%.
- Read
- 20 min
- Source
- arXiv:2608.23552
Recursive Harness Self-Improvement
Treat the "harness" around a coding agent — the roles, instructions, message contracts, and workflow steps — as an editable block of text, then rewrite it a few times by having a judge compare each version's output to the last one, and a cheap low-effort agent starts beating its own most-expensive setting at up to 60% lower cost.
- Read
- 22 min
- Source
- arXiv:2607.15524
Self-Harness: Harnesses That Improve Themselves
An LLM agent reads its own failure logs, proposes small edits to the scaffolding it runs inside (prompts, tools, policies), and keeps only the edits that pass a regression test — so the agent tunes its own "operating system" without a human engineer or a smarter model helping.
- Read
- 18 min
- Source
- arXiv:2606.09498
Self-Revising Discovery Systems for Science: A Categorical Framework for Agentic AI
A precise, auditable line between an AI that gets better at answering inside a fixed vocabulary (*search*) and an AI that enlarges the vocabulary itself (*discovery*) — drawn with category theory and demonstrated by two working scientific-discovery systems.
- Read
- 22 min
- Source
- arXiv:2606.01444
SkillOpt: Executive Strategy for Self-Evolving Agent Skills
Treat the agent's skill file as a trainable parameter and run a real optimizer over it — sample rollouts, propose small text edits, and keep an edit only if a held-out score goes up — so a frozen model reliably gets better without touching its weights.
- Read
- 18 min
- Source
- arXiv:2605.23904
Training-Free Group Relative Policy Optimization
Instead of fine-tuning a model's weights with reinforcement learning, you run the *same* RL loop but let the model write itself a growing playbook of natural-language "experiences" — and just paste that playbook into the prompt at inference time.
- Read
- 16 min
- Source
- arXiv:2510.08191
WikiSkill: Compiling Agent Experience into Persistent Knowledge for Skill Evolution
WikiSkill splits agent self-improvement into three layers — raw traces, a persistent "wiki" of root-caused knowledge that is never rolled back, and a mutable, gated skill set — so that skill development builds on accumulating understanding instead of on a flat pile of past proposals.
- Read
- 18 min
- Source
- arXiv:2608.27454
Write, Execute, Refine: From Skill Followers to Skill Optimizers via Reinforcement Learning from Execution Feedback
WER trains a small, separate "Skill Optimizer" model with reinforcement learning to write and rewrite the natural-language how-to documents ("skills") that guide a frozen tool-using agent, using real pass/fail execution outcomes — not another LLM's opinion — as the training signal.
- Read
- 16 min
- Source
- arXiv:2608.17587