AI Papers Reader

Personalized digests of latest AI research

View on GitHub

Coding Agents That Learn From Their Own Work

Most existing agents remain largely static after deployment. They can inspect repositories, edit files, run tests, and fix bugs, but they rarely keep reusable experience from one task to the next. Repositories evolve, dependencies change, and conventions vary, so an agent that cannot adapt may repeat similar mistakes. Researchers from Nanjing University of Science and Technology and Nanjing University reviewed the emerging area of “self-evolving coding agents”—systems that update their behavior or internal components based on earlier coding attempts and software-specific feedback.

The central insight is that software engineering gives agents particularly concrete feedback: unit tests, compiler diagnostics, runtime traces, lint warnings, and continuous-integration results can all become learning signals. The authors distinguish these systems from conventional coding agents and general self-evolving agents. Their object-centered taxonomy organizes work by what evolves: framework, memory, skills and tools, model, or workflow and topology. Timing can be task-time, post-task, or stage-wise; evidence can be outcome scores, environmental feedback, or trajectories.

One concrete example is Live-SWE-Agent. According to the survey, it starts from a minimal bash-only scaffold—the code that orchestrates the agent’s actions—and can create and revise custom tools, such as editors, code-search utilities, and domain-specific analyzers, while solving repository-level issues. The tools are judged by how much they help with repository inspection, editing, execution, and testing. This is task-time evolution: the agent changes its toolkit before the task ends, rather than learning only after final success or failure.

Other systems evolve different components. Repository memory systems turn historical commits and issue links into knowledge for code localization. gskill learns repository-specific skills—architecture, conventions, testing procedures, pitfalls—by generating verifiable tasks and keeping skill documents that help agent-generated patches pass tests. Self-play SWE-RL couples bug generation and repair: the agent creates bugs in real repositories, tries to repair them, and uses verified outcomes to improve later solvers. A “Darwin Gödel Machine” line of work keeps an archive of agent variants and retains self-modifications that improve benchmark performance.

Because this is a survey, it reports no new benchmark results. Its main contribution is a common vocabulary for a fragmented literature. Still, the authors identify evaluation gaps. Most current measurements emphasize short-horizon success—pass rates or resolve rates on benchmarks such as SWE-bench, HumanEval, MBPP, and LiveCodeBench. Those numbers do not reveal whether an improvement came from memory, skills, workflows, or model updates. Many systems report cost, runtime, token usage, or retrieval overhead, but maintainability and long-term robustness are harder to quantify.

The key open problem is trustworthiness. Tests can be incomplete, logs ambiguous, and benchmark signals overfittable. If an agent stores noisy experiences, learns brittle skills, or rewrites its own framework based on misleading feedback, the harm can persist across future tasks. Memory can become stale, and evolved workflows may overfit benchmark feedback or add coordination overhead. Evolution also has costs: extra search, repeated test execution, and model retraining. The authors conclude that the goal is not just to make coding agents evolve, but to make that evolution reliable, auditable, and safe enough for real software engineering.