Agentic systems are increasingly expected to improve after deployment, yet single-entity self-evolution is often bounded by a static learning context, such as fixed tasks and feedback. This survey focuses on co-evolution in agentic systems, a multi-component form of self-evolution in which multiple agents and their environment impose adaptive pressure on one another. To organize existing papers, we propose a progressive three-stage taxonomy that traces how the system gradually sheds human-engineered constraints. Agent--Agent Co-Evolution studies how agents adapt through dynamic peers, including adversarial, collaborative, and organizational adaptation. Agent--Environment Co-Evolution extends this loop to adaptive tasks, feedback, and interaction spaces that change with the agents. Meta Co-Evolution further explores the possibility of making the evolution mechanism itself evolvable. We also discuss open challenges in evaluating such systems, scaling them across multiple components, and keeping increasingly autonomous evolutionary processes safe and controllable. This survey provides a unified foundation for building robust and open-ended agentic systems that can improve beyond fixed human-designed paths.
Alex: Welcome to another episode of ResearchPod. Today, we're looking at a survey on something called co-evolution in agentic systems—essentially, how AI agents can keep improving long after they've been built and released.
Sam: So this is about moving away from the current model, where an AI is trained, released, and then basically frozen? The argument is that our environments are too rigid?
Alex: That's right. As AI agents become more capable, the bottleneck isn't usually the model's design—it's the fixed, human-made environments they're placed in. Those environments stop challenging the agent, so the agent stops growing.
Sam: So instead of a static setup, this research proposes a "co-evolutionary" approach—where the agent and its environment adapt to each other at the same time. How does that actually work in practice?
Alex: The paper breaks it down into three stages, each building on the last. Think of it like leveling up in a game. First, you learn from other players. Then the game itself starts adapting to you. And finally, the rules of how the game adapts also start changing.
Sam: So the first stage—where AI systems learn from each other—how does that create real improvement?
Alex: The paper draws on a concept from biology called the "Red Queen Effect." The name comes from a line in Alice in Wonderland—the Red Queen tells Alice she has to keep running just to stay in the same place. In nature, this describes how prey animals evolve faster escape skills because predators are also evolving. Neither side can afford to stop. Apply that to AI: if you have two agents competing—say, one trying to find security vulnerabilities and one trying to patch them—improving one automatically forces the other to improve. Neither can coast.
Sam: That makes sense. But if the rules of the game never change, don't both agents eventually hit a ceiling?
Alex: Exactly—and that's the limitation the paper identifies. Both agents can get very good at a narrow task without developing genuinely new capabilities. That's where the second stage comes in: making the environment itself evolve.
Sam: How do you make an environment actually evolve, rather than just getting harder?
Alex: The key distinction is that the environment doesn't just scale up difficulty—it changes shape based on what the agent does. The agent's own behavior feeds back into the system and reshapes the tasks, the feedback signals, even the space of possible interactions. It's no longer a static obstacle course.
Sam: Like a video game that watches how you play and rewrites its own levels—not just making enemies faster, but introducing entirely new mechanics because it noticed you'd mastered the old ones.
Alex: That's a good way to put it. And the third stage, which the paper calls "Meta Co-Evolution," takes this one step further. It makes the evolutionary process itself something that can change.
Sam: Wait—so the system isn't just evolving. It's rewriting the rules of how it evolves?
Alex: Yes. At this level, the system decides what aspects of itself to develop, and it updates how it measures its own progress. It moves from being a tool that responds to external feedback, to something that manages its own developmental strategy. And if it's constantly generating its own challenges and updating its own success criteria, the theory is it could keep improving indefinitely—without hitting the ceiling that fixed environments create.
Sam: That's the goal the paper calls "open-endedness"?
Alex: Exactly. Building systems that keep generating genuine novelty rather than converging on a fixed solution and stopping there. But that framing raises an obvious concern. If the system is rewriting its own rules, what stops it from finding a shortcut? Gaming its own evaluation rather than actually getting better?
Sam: Right—if you're grading yourself, there's a temptation to lower the bar.
Alex: And that is one of the paper's central warnings. High success rates can be misleading. An agent might discover a way to score well on its own benchmarks without developing the underlying skills those benchmarks were meant to measure. The paper calls this "exploitative behavior"—and it's genuinely difficult to detect from the outside.
Sam: So how do the authors suggest we guard against that?
Alex: They argue for what they call "process-level testing." Instead of only checking the final score, you examine whether the individual components—things like memory, reasoning, or the agent's internal tools—are actually becoming more capable on their own terms.
Sam: Like a teacher who doesn't just mark the answer right or wrong, but asks the student to explain their working. The grade alone doesn't tell you whether they understood the material or just memorized a pattern.
Alex: Exactly. The paper also suggests a technique called "historical cross-play"—testing a current version of an agent against its own earlier versions. If the newer agent consistently outperforms its past self in ways that can't be explained by narrow memorization, that's stronger evidence of genuine improvement.
Sam: So the real challenge this survey is pointing to isn't just "how do we build a smarter model"—it's "how do we build an evolutionary process that stays honest with itself."
Alex: That's the fundamental shift the paper is arguing for. The goal isn't just productive pressure that makes agents improve—it's pressure that doesn't collapse into instability or self-deception. Getting that balance right is, the authors suggest, one of the more significant open problems in building AI systems that can genuinely grow over time.
Sam: The idea of a system that manages its own development raises as many questions as it answers.
Alex: That's probably the right response. These are early frameworks, not finished solutions. But mapping the problem clearly is a necessary first step. Thanks for listening to ResearchPod.