Self-Evolving Coding Agents

The Problem: Static Agents in a Dynamic World

Today's coding agents—AI systems that inspect code, run tests, debug, and generate fixes—are largely frozen after deployment. Yet software development is fundamentally dynamic: repositories evolve, dependencies break, tests fail, and each repair attempt yields lessons that could improve future performance. This paper surveys an emerging field where coding agents instead learn and adapt from their own experience, updating their strategies, memory, tools, or even model weights based on real feedback from the development process.

The authors argue that software engineering is a uniquely rich domain for agent self-evolution. Unlike general-purpose AI systems, coding agents have access to executable feedback (tests pass or fail), repository-level context (the full codebase and its history), and coding trajectories (sequences of attempts and outcomes). These signals are concrete, measurable, and directly tied to success or failure—a gift that most other AI domains lack.

What Evolves, When, and Why

The survey's central contribution is a structured taxonomy. The authors identify five categories of what can evolve:

1. Framework — how the agent reasons and plans
2. Memory — what prior interactions the agent remembers and retrieves
3. Skills — reusable procedures or prompting patterns the agent learns
4. Tools — which functions or APIs the agent can call
5. Models or collaboration structures — swapping or coordinating multiple LLMs

Orthogonal to what evolves are two timing dimensions: when evolution happens (immediately after failure, periodically, or in batched offline cycles) and what drives it (executable test results, error messages, user feedback, or execution traces).

Why It Matters—and What Could Go Wrong

The survey identifies why this matters: agents that adapt become more sample-efficient, can handle novel repositories without retraining, and accumulate expertise over time. Yet self-evolution introduces genuine risks. Feedback reliability becomes critical—a passing test doesn't guarantee correct reasoning, and false positives corrupt learning. Benchmark overfitting looms when agents optimize for evaluation datasets rather than generalizing. Safety is at stake if agents learn and deploy unsafe patterns. Maintainability and cost grow as evolving agents become harder to audit and debug. Finally, generalization remains uncertain: improvements on one codebase may not transfer.

The Landscape

By synthesizing recent work across these dimensions, the authors map the field's current state and expose open questions. Which signals most reliably drive improvement? How can we evolve without overfitting? Can agents learn safely? The survey doesn't solve these, but it provides a conceptual foundation—defining the boundary between a self-evolving coding agent and a static one, and between coding-specific self-evolution and general-purpose agent learning.

The result is less a finished answer than a compass for the next wave of work: systems that learn from every deployment, every test run, every fixed bug, and use that accumulating wisdom to become more reliable and capable. For practitioners building production coding assistants, it clarifies what's at stake.