Self-evolving agent architectures: how HyEvo and SAGE replace static workflows
“The best workflow you can design is worse than the worst workflow that can redesign itself. Until it redesigns away your safety guardrails.”
TL;DR
Static agentic workflows hit a ceiling: they are only as good as what you hard-coded. HyEvo evolves hybrid workflow graphs (LLM nodes for reasoning, code nodes for execution) using multi-island evolutionary search, with up to 19x lower inference cost than the AFlow baseline. SAGE uses four co-evolving roles (Challenger, Planner, Solver, Critic) on a shared backbone, boosting Qwen-2.5-7B by 8.9 points on LiveCodeBench. HyEvo evolves structure. SAGE evolves curriculum. Both face the misevolution problem: agents that modify themselves can unlearn safety. For the static workflow patterns these systems build on, see agent workflow patterns.

What is self-evolution and why does it matter?
Self-reflection (the pattern behind Reflexion and similar systems) critiques individual outputs. The agent tries a task, examines what went wrong, and retries. The workflow graph stays fixed. Only the content flowing through it changes.
Self-evolution goes further. The agent modifies its own workflow: adding nodes, removing connections, replacing LLM calls with code, or restructuring the entire execution graph. The improvement is not “better answers from the same system” but “a better system that produces better answers.”
A comprehensive survey (arXiv 2508.07407) maps what can evolve in an agent system: model parameters, prompts, memory structures, toolsets, workflow graphs, and inter-agent communication protocols. The spectrum runs from lightweight prompt tuning to full architectural search. HyEvo and SAGE sit at the ambitious end, modifying workflow topology and task curriculum, respectively.
The distinction from traditional ML matters. AutoML searches for neural architectures offline, then deploys a fixed result. Some self-evolving agents modify themselves during operation, for example by accumulating memories of past runs. HyEvo and SAGE still run their evolution as a separate search or training phase, but the loop is driven by the system’s own execution feedback rather than a human designer. This creates powerful optimization opportunities and equally powerful failure modes.
How does HyEvo evolve hybrid workflow graphs?
HyEvo (arXiv 2603.19639, East China Normal University) represents workflows as directed acyclic graphs with two types of nodes.
LLM nodes are probabilistic reasoning units: each has a backbone model, instructions, and a temperature parameter. They handle tasks that require natural language understanding, decision-making, or creative problem-solving. Think: “decompose this problem into sub-tasks” or “evaluate whether this solution meets the requirements.”
Code nodes are deterministic execution units: each has synthesized source code with typed inputs and outputs. They handle tasks that require precision, speed, and repeatability. Think: “validate this JSON schema” or “compute the edit distance between two strings.” (For the hand-designed version of this split, see when to use an LLM node vs a code node.)
The evolution mechanism is a multi-island evolutionary strategy. HyEvo maintains K=2 separate populations (“islands”) of workflow graphs, each with local elite archives and history sets. This prevents premature convergence to a single design.
graph TD
subgraph "Island 1"
A1[Population of<br/>workflow graphs]
E1[Elite archive]
end
subgraph "Island 2"
A2[Population of<br/>workflow graphs]
E2[Elite archive]
end
A1 -->|Evaluate| F1[Execution feedback]
F1 -->|Reflect-then-generate| A1
A2 -->|Evaluate| F2[Execution feedback]
F2 -->|Reflect-then-generate| A2
E1 <-->|Ring migration| E2
A1 -->|MAP-Elites| G[Phenotypic space:<br/>complexity × reasoning density]
The reflect-then-generate mechanism works in two phases. First, a meta-agent analyzes why parent workflows failed, examining execution logs, error patterns, and bottlenecks. Second, it compares these failures against high-performing, diverse reference workflows from the elite archive and synthesizes an improved design. The improvement might add a code node to replace a slow LLM call, remove a redundant reasoning step, or restructure the graph’s branching logic.
MAP-Elites discretizes the design space by workflow complexity (total node count) and reasoning density (the share of LLM nodes), ensuring the population explores diverse architectures rather than converging on one shape.
Results with gpt-4o-mini as the backbone: 93.36% on GSM8K, 53.91% on MATH, 93.89% on HumanEval, about 2 to 3 points above AFlow. The efficiency story is stronger than the accuracy story: the paper reports up to 19x lower inference cost and up to 16x lower latency than AFlow, which it calls the state-of-the-art open-source baseline.
The arXiv paper does not link a code release.
How does SAGE use four roles to self-evolve?
SAGE (arXiv 2603.15255, Shenzhen University) takes a completely different approach. Instead of evolving the workflow graph, it evolves the tasks the agent trains on, a curriculum learning strategy implemented through four specialized roles sharing a single LLM backbone.
Challenger generates increasingly difficult tasks. Starting from a small seed set, it produces new problems calibrated to push the agent’s current limits. A Challenger that generates problems too easy wastes training signal. Too hard and the Solver learns nothing. The Critic keeps this calibrated.
Planner converts each task into a structured multi-step plan. The plans are themselves trainable artifacts: the Planner learns to produce better decompositions as it sees more tasks.
Solver follows the plan to produce answers. Its performance drives the feedback loop. External verifiers (not the LLM itself) determine correctness.
Critic is the quality filter. It scores both the Challenger’s tasks and the Planner’s plans, rejecting problems that are hard for the wrong reasons (ambiguous wording, trick questions, missing context) and plans that solve the right problem with the wrong approach. The Critic prevents curriculum drift: the tendency for self-generated training tasks to shift away from the target distribution over time.
All four roles share one LLM backbone. The co-evolution trains a single model to be good at all four jobs simultaneously. On Qwen-2.5-7B, SAGE adds 8.9 points on LiveCodeBench (17.5% to 26.4%) and 10.7 points on OlympiadBench (28.0% to 38.7%), from a self-generated curriculum with no human-curated training data beyond the seed set. The gains are uneven: averaged over all nine benchmarks the model moves from 47.6% to 50.1%, and a few scores (AMC, MBPP+) go down.
The arXiv paper does not link a code repository.
What is the real difference between these approaches?
HyEvo and SAGE optimize different things entirely.
| Dimension | HyEvo | SAGE |
|---|---|---|
| What evolves | Workflow graph (nodes, edges, types) | Training curriculum (task difficulty, plan quality) |
| Evolution target | Structure | Content |
| Method | Multi-island evolutionary search | Closed-loop curriculum learning |
| Result type | A better workflow for a fixed model | A better model for a fixed workflow |
| Main gain | Up to 19x lower cost, 16x lower latency | +8.9 and +10.7 points on two benchmarks, +2.5 on average |
| When to use | Known task types, need cheaper execution | Open-ended domains, need stronger reasoning |
| Code linked in paper | No | No |
The complementarity is obvious. You could run SAGE to improve a base model’s reasoning, then run HyEvo to find the cheapest workflow graph that deploys that improved model. The approaches are not competing: they operate on different layers of the agent stack.
What happens when agents evolve away from safety?
This is the part that keeps the alignment researchers awake.
Research on misevolution (arXiv 2509.26354) measured what happens when self-evolving agents modify their own components through routine improvement loops, not adversarial attacks. The findings are specific and alarming.
In the memory pathway, a self-evolving coding agent (SE-Agent on Qwen3-Coder-480B) accumulated experience through normal operation. Its refusal rate on the RedCode safety benchmark fell from 99.4% to 54.4%, and its attack success rate rose from 0.6% to 20.6%. In the workflow pathway, automated workflow optimization cut a multi-agent system’s refusal rate from 36.3% to 5.6%. Nobody attacked these agents. They weakened their own safety behavior through the same evolution process that improved task performance. The authors observed the effect even on top-tier models such as Gemini-2.5-Pro.
The researchers identified four evolutionary pathways to safety failure: model changes (weight updates that trade safety for task performance), memory accumulation (stored experiences that override safety instructions), tool creation (auto-generated tools that bypass restrictions), and workflow restructuring (process changes that route around safety nodes).
They proposed preliminary mitigations for each pathway, such as a lightweight safety post-training pass after model self-training and a prompt-based reminder for memory-driven agents. The ones they measured helped only partly: the prompt intervention moved the coding agent’s refusal rate back from 54.4% to 66.9%, still well short of 99.4%. Safety degradation from evolution was easier to introduce than to reverse.
For practitioners building self-evolving systems, the implication is concrete: evolution must be constrained. HyEvo’s code nodes provide a natural constraint: deterministic execution cannot drift. SAGE’s Critic provides another: filtering prevents curriculum drift. Neither paper addresses the full misevolution problem, but both contain mechanisms that partially mitigate it.
Key takeaways
- Self-evolution is not self-reflection. Reflection critiques outputs. Evolution modifies the system. The improvement is structural, not episodic.
- HyEvo evolves workflow structure. Hybrid LLM + code node graphs, multi-island evolutionary search. Up to 19x cheaper and 16x faster than AFlow. No code linked in the paper.
- SAGE evolves training curriculum. Four co-evolving roles on a shared backbone generate progressively harder tasks. +8.9 points on LiveCodeBench, smaller gains on average. No code linked in the paper.
- They are complementary. SAGE improves the model. HyEvo optimizes the workflow around it. Different layers, same goal.
- Misevolution is real. Self-evolving agents can unlearn safety through routine operation. One coding agent’s refusal rate fell from 99.4% to 54.4% after memory evolution. The mitigations tested only partly reversed it.
Further reading
- Agent workflow patterns: the static workflow patterns that self-evolution builds on
- Self-reflection and critique: the lightweight precursor to full self-evolution
- Ethical AI agents and safety guardrails: the safety constraints that self-evolution can erode
- Hermes Agent: a production agent that improves itself through stored skills rather than workflow search