AgentStream: How Well Do Self-Evolving LLM Agents Perform Under Streaming Tasks?

The Problem: Self-Evolving Agents Don't Face the Real World

Large language model agents can improve themselves by learning from their own mistakes—a capability called self-evolution. But nearly all research tests these agents on independent tasks in isolation. The authors' core claim is that this testing approach is unrealistic and misleading: when agents must continuously adapt to streams of diverse, shifting tasks (as they would in practice), their self-evolution performance degrades unpredictably and depends heavily on which model and method you choose.

To expose this gap, the authors built AgentStream, a benchmark framework that measures five different self-evolving methods across three large language models under three increasingly challenging streaming scenarios. Their key finding: self-evolution reliability is not stable across scenarios, benefits plateau or decline with stronger models in counterintuitive ways, and no single method works best across all combinations of model and task stream.

How the Framework Works

AgentStream reorganizes existing agent benchmarks into configurable task streams and runs three test scenarios of increasing complexity:

1. Isolated: Standard setup—each task evaluated independently, no cross-task learning.
2. Sequential: Tasks arrive one after another in the same domain (e.g., all QA, all coding). Agents adapt as they go.
3. Interleaved: Tasks arrive in mixed domains and complexities. Agents must adapt to frequent domain shifts while retaining prior knowledge.

The authors then evaluate five representative self-evolving methods (specific techniques not detailed in the abstract) across three frontier foundation models, measuring how performance changes as tasks stream in. They track whether improvements from one task transfer to the next, and whether domain shifts cause forgetting or interference.

Why the Results Matter

The findings overturn intuitive expectations. First, self-evolution reliability varies sharply: a method that works well in isolated settings may fail under sequential or interleaved task streams. Second, stronger models don't always benefit more from self-evolution. The relationship is non-monotonic—performance improvements from self-evolution plateau or even reverse as model capability increases, suggesting that stronger base models may have different dynamics than weaker ones. Third, no method dominates universally, meaning practitioners cannot pick a single self-evolving strategy; they must match method to model and expected task distribution.

These findings suggest the field has been evaluating self-evolving agents in an overly simplified way. Independent tasks don't reflect production deployments where agents encounter continuous, diverse workloads. The streaming perspective reveals brittleness that single-task benchmarks hide.

The authors argue for a shift in evaluation culture: self-evolving agents should be benchmarked against realistic task streams, not isolated problems. This guidance applies immediately to anyone designing agent systems—it highlights that self-evolution is context-dependent and requires careful validation under the specific streaming patterns your deployment will see.