Self-Evolving Software Engineering Agents

• Self-evolving software engineering agents are autonomous systems that continuously refine their own architectures and toolchains via self-reflection, live tool synthesis, and collaborative multi-agent methods.
• They employ methodologies like on-the-fly scaffold evolution, meta tool learning, and trajectory optimization to achieve rapid adaptation and significant performance improvements.
• Real-world applications include enhanced security intelligence extraction, automated code repair, and GUI task automation, with empirical benchmarks demonstrating notable gains.

Self-evolving software engineering agents are autonomous systems that continuously adapt, augment, and refine their own architecture, policies, or toolchains to optimize performance on software engineering tasks. They integrate advanced LLMs or multi-modal models with mechanisms for self-reflection, live tool synthesis, cross-trajectory evolution, or multi-agent collaboration. This approach enables performance gains, rapid adaptation to novel problem types, and the emergence of tailored strategies without requiring continual human intervention or costly offline retraining.

1. Foundational Architectures and Methodologies

Self-evolving agents appear in several conceptual forms. Mono-agent scaffolds such as Live-SWE-agent start from a minimal REPL loop with access only to basic shell commands, then autonomously synthesize or refine task-specific scripts or tools as new challenges emerge during the live solution process (Xia et al., 17 Nov 2025). By comparison, multi-agent frameworks orchestrate specialized sub-agents for information retrieval, interpretation, validation, and knowledge graph augmentation—Evolaris exemplifies this, operating over a common context store to support high-throughput, iterative security intelligence extraction (Liu et al., 6 Oct 2025).

Self-evolution mechanisms are instantiated via online tool creation, scaffold refinement, meta-tool learning, and agent-level collaboration or debate. The design space spans:

• On-the-fly scaffold evolution (Live-SWE-agent): The agent modifies its own REPL loop, prompt, and discoverable toolset during task solution, with reflection hooks prompting consideration of new or revised tools at each step (Xia et al., 17 Nov 2025).
• Multi-agent collaboration with textual backpropagation (EvoMAC): Agents coordinate via DAGs, with test feedback producing “textual gradients” that drive prompt or workflow rewiring (Hu et al., 22 Oct 2024).
• Self-referential code editing (SICA): The agent iteratively edits its own codebase and tool interfaces, benchmarking and archiving successive agent versions without any model gradient updates (Robeyns et al., 21 Apr 2025).
• Meta tool learning (MetaAgent): The system accumulates new in-house tools and knowledge snippets as it learns, using self- and verified-reflection to update dynamic context across all future tasks (Qian et al., 1 Aug 2025).

2. Self-Evolution Algorithms and Trajectory Optimization

A core theme is the handling of agent interaction trajectories. SE-Agent formalizes self-evolution as an iterative process over agent trajectories, with mechanisms for revision (local introspective improvement), recombination (cross-trajectory fusion or segment transfer), and refinement (selection of high-reward, diverse, or novel strategies) (Lin et al., 4 Aug 2025). This paradigm is inspired by genetic algorithms but operates at the level of full task solutions, not single actions.

The algorithmic structure typically includes:

• Generation and mutation of diverse candidate trajectories.
• Cross-trajectory recombination to inject novel heuristics or sequence segments.
• Hybrid selection: a top-K reward filter with explicit diversity maintenance, using trajectory-dissimilarity metrics (e.g., stepwise edit distance).
• Iterative loop halts on a plateau in the improvement metric.

Empirical evidence demonstrates substantial relative improvements (e.g., up to 55% gain in correct patch generation on SWE-bench Verified) over both baseline and MCTS-powered agents (Lin et al., 4 Aug 2025).

3. Knowledge Representation, Reflection, and Retrospective Learning

Effective evolution requires knowledge persistence and adaptive feedback. Agents typically maintain structured records (e.g., graphs, repositories of past tool call results, code diffs), and implement explicit self-reflection or dynamic context augmentation.

• MetaAgent maintains a persistent knowledge base of all tool outputs, self-reflection, and verified-reflection summaries, and enables construction of mini-tools from recurring usage patterns (Qian et al., 1 Aug 2025).
• SICA archives iterations, enabling the agent to analyze performance differences among versions and generate targeted codebase patches (Robeyns et al., 21 Apr 2025).
• Evolaris represents all threat intelligence as a knowledge graph with entity and edge embeddings updated via link-prediction objectives, incorporating both raw discoveries and reinforcement-style reward signals tied to real-world validations (Liu et al., 6 Oct 2025).
• Agentsway formalizes feedback-driven, retrospective LLM fine-tuning, with each phase’s outputs forming training examples for specialized LLMs deployed in subsequent cycles (Bandara et al., 26 Oct 2025).

Shared representations and learning buffers are key to continual adaptation and avoidance of catastrophic forgetting (Pan et al., 30 Dec 2024).

4. Multi-Agent Coordination, Debate, and Context Sharing

In multi-agent self-evolving systems, coordination is mediated by a shared context or blackboard pattern. Each agent independently reads and writes to a central knowledge store or workflow graph (Liu et al., 6 Oct 2025, Hu et al., 22 Oct 2024). Specialized agent types—for example, planning, prompting, coding, testing, fine-tuning—implement closed-loop control over the software development lifecycle (Agentsway (Bandara et al., 26 Oct 2025)). Collaborative decision processes are augmented by Value Agent–Discriminator Agent architectures, where numerical and qualitative feedback drive search and debate leading to automated selection of the most robust solution (Antoniades et al., 26 Oct 2024).

EvoMAC demonstrates dynamic workflow reconfiguration via “textual backpropagation,” allowing new agents to be spawned, phased out, or retasked in direct response to compiler-verified feedback (Hu et al., 22 Oct 2024).

5. Quantitative Evaluation and Empirical Outcomes

Self-evolving agents are empirically validated on benchmarks such as SWE-bench Verified, SWE-Bench Pro, LiveCodeBench, and custom real-world datasets. Measured solve rates, latency, and cost consistently show improvement over static or fixed-architecture baselines.

Table: Example Solve Rates on SWE-bench Verified and Pro (Xia et al., 17 Nov 2025Robeyns et al., 21 Apr 2025Lin et al., 4 Aug 2025) | Method | Solve Rate (Verified) | Solve Rate (Pro) | Offline Cost (h) | |-------------------|----------------------|------------------|------------------| | Live-SWE-agent | 75.4% | 45.8% | 0 | | SICA | 50.0% | – | ∞ | | SE-Agent | up to 61.2% (open) | – | moderate | | DGM/HGM | 53.3%/56.7% | – | >500–1000 |

Additional findings include:

• Rapid within-task evolution (average of ~3.28 tools created per issue for Live-SWE-agent), with overhead below 10% cost/time (Xia et al., 17 Nov 2025).
• Evolving toolsets and context snippets reduce the number of debugging iterations and improve pass@1 rates on code synthesis (Qian et al., 1 Aug 2025).
• Scalability demonstrated by throughput (Evolaris: ~10,000 pages/hour; F1 = 0.905) and rapid adaptation to new threat patterns in cybersecurity use-cases (Liu et al., 6 Oct 2025).
• In SEAgent, specialist-to-generalist distillation achieves >23% improvement on complex GUI task suites by aggregating specialist knowledge (Sun et al., 6 Aug 2025).

6. Practical Limitations and Future Trends

Despite the demonstrated gains, key challenges include:

• No formal convergence guarantees for most on-the-fly or meta-learning methods due to unbounded scaffold and tool spaces (Xia et al., 17 Nov 2025).
• Absence of knowledge accumulation across episodes in some frameworks; tools are often discarded at task end, suggesting the need for serialization of reusable skills (Xia et al., 17 Nov 2025).
• Instability in evolution for weaker LLMs or in adversarial scenario, underscoring the need for robust reflection triggers and risk-aware self-evolution (Xia et al., 17 Nov 2025).
• LLM call and computation costs remain obstacles in deep search or multi-agent setups (Antoniades et al., 26 Oct 2024, Lin et al., 4 Aug 2025).
• Reliable environment feedback and validation remains a bottleneck for tasks beyond software engineering, or where ground truth is unavailable (Sun et al., 6 Aug 2025, Cai et al., 1 Oct 2025, Hu et al., 22 Oct 2024).
• Scaling to multi-task, cross-organization, or safety- and security-critical domains introduces new requirements for governance and formal verification (Bandara et al., 26 Oct 2025).

Proposed directions include persistent tool and knowledge bases, distributed agent collaboration, hybrid learning (meta-RL, continual learning), formal reward/validation models, and integrated pipelines for privacy and responsible AI (Bandara et al., 26 Oct 2025, Pan et al., 30 Dec 2024).

7. Case Studies and Domain Applications

The flexibility of self-evolving agents spans diverse domains:

• Evolaris demonstrates tracking of the W4SP “colorwed” npm stealer, with iterative growth in expressive knowledge graphs and rapid F1 gains from 0.80 (L=36 h) to 0.95 (L=5 h) as new signals and validation feedback are incorporated (Liu et al., 6 Oct 2025).
• SICA and Live-SWE-agent outperform static and even heavily pre-trained agents on end-to-end software repair (up to 75.4% solve rate without scaling) with zero offline training, highlighting practical viability for real-world systems (Xia et al., 17 Nov 2025, Robeyns et al., 21 Apr 2025).
• SEAgent achieves state-of-the-art success rates on GUI automation tasks across specialized and generalist software platforms, distilling experience from specialist agents into a robust generalist (Sun et al., 6 Aug 2025).
• MetaAgent’s meta tool learning and reflection–driven context augmentation halve debugging iteration counts and improve reliability across code synthesis, test generation, and CI/CD pipeline orchestration (Qian et al., 1 Aug 2025).
• Agentsway pilots in legal automation show measurable increases in F1 and decreases in defect density through fine-tuned, role-specialized agent feedback loops (Bandara et al., 26 Oct 2025).

These applications illustrate the generality, adaptability, and measured effectiveness of self-evolving software engineering agents across multiple industrial and research domains.