EEVEE tackles prompt learning across real-world streams

EEVEE is a multi-dataset test-time prompt learning framework that reduces cross-dataset interference for LLM agents.

• Research org: Unspecified in arXiv abstract
• Core data: Improves average multi-benchmark scores by 10.38 and 24.32 points
• Breakthrough: Router partitions inputs into task clusters and co-evolves with prompts

Most prompt-learning systems are built for a clean lab setup: one dataset, one task distribution, one benchmark at a time. That is not how production workloads behave. Real-world agent systems see mixed streams of tasks from different domains, and the paper argues that this heterogeneity is exactly where existing methods start to break down.

EEVEE: Towards Test-time Prompt Learning in the Real World for Self-Improving Agents is aimed at that gap. The paper proposes a way for LLM agents to keep learning prompts at test time while handling multiple datasets and task streams without letting each new batch of inputs interfere with the others.

For developers, the interesting part is not just that EEVEE learns online. It is that the framework explicitly treats routing and prompt adaptation as coupled problems, which is a more realistic model of how messy production data behaves.

What problem EEVEE is trying to fix

The abstract makes the core issue pretty clear: existing test-time prompt learning methods are mostly designed for single-dataset settings. That works if you are evaluating on one benchmark, but it becomes fragile when the input stream mixes domains, datasets, and task distributions.

That mismatch matters because real-world agent deployments rarely get neatly separated data. A self-improving agent may see customer support tasks, internal search tasks, and domain-specific requests in the same stream. If the learning system assumes everything belongs to one distribution, prompt updates can start interfering with one another.

EEVEE’s goal is to make test-time prompt learning useful in that setting. Instead of optimizing for a single benchmark in isolation, it is built for heterogeneous task streams where the model has to keep adapting without losing stability.

The paper frames this as a practical limitation of prior work: methods may look strong on one benchmark, but that does not automatically translate to a multi-dataset environment. The new framework is meant to preserve learning capability while improving robustness under mixed inputs.

How the method works in plain English

EEVEE adds a router in front of the prompt-learning system. The router’s job is to partition incoming inputs into task clusters and send them to prompt configurations that are better suited for those clusters.

That design is meant to reduce cross-dataset interference. In other words, instead of letting one stream of updates blur together with another, EEVEE tries to keep related inputs grouped and handled in a more targeted way.

The second piece is the router-prompt co-evolution strategy. The abstract describes this as interleaved router and prompt learning phases, which are used to handle the mutual dependency between routing and prompting.

That dependency is the key idea. The router needs good prompts to decide how to organize tasks, and the prompts need good routing to avoid being polluted by unrelated data. EEVEE does not pretend those can be optimized independently; it alternates between them so each component can adapt to the other.

In practical terms, this is closer to a systems view than a pure algorithmic trick. The framework is trying to make prompt learning behave like an online control loop: classify the incoming task, adapt the prompt, then refine the routing based on what happened.

What the paper actually shows

The abstract says the authors ran experiments across multiple datasets. It does not list the full benchmark suite in the source text here, so the safest reading is that the evaluation spans heterogeneous data streams rather than a single benchmark.

The reported results are the main concrete numbers available. EEVEE improves average multi-benchmark scores by 10.38 and 24.32 points over Qwen3-4B-Instruct and DeepSeek-V3.2, respectively. It also surpasses SOTA methods GEPA and ACE by up to 37.2% and 48.2%.

Those numbers suggest two things. First, the framework is not just keeping pace with existing systems; it is making a meaningful jump over them in the multi-benchmark setting. Second, the gains are specifically tied to heterogeneous streams, which is where the paper says prior methods are weakest.

At the same time, the abstract does not provide the full experimental context in the notes we have here. There are no per-dataset breakdowns, no latency numbers, and no details on the exact benchmark definitions in the supplied source. So while the results sound strong, the public abstract alone does not let us inspect where the gains come from or how evenly they are distributed.

Why developers should care

If you are building agents that learn from live traffic, this paper points at a real operational problem: adaptation can become brittle when the input stream is not uniform. A prompt update that helps one task family may hurt another if the system treats every new example as part of one shared pool.

EEVEE’s router-first design is interesting because it introduces a structure that many production systems already need in some form: task separation. Instead of assuming one prompt policy can absorb everything, it tries to route similar tasks together before updating prompts.

That makes the framework relevant for teams thinking about continual adaptation, agent personalization, or any setup where test-time learning has to happen under mixed workloads. The paper suggests that prompt learning becomes more practical when routing is treated as part of the learning loop, not an afterthought.

There are still open questions. The abstract does not tell us how expensive the router-prompt co-evolution process is, how sensitive it is to task clustering quality, or how it behaves under severe distribution shift. It also does not show whether the gains hold equally across all datasets, or whether some benchmark families benefit more than others.

Even with those limits, the paper’s direction is easy to understand: if you want self-improving agents to work outside the lab, they need to learn from messy streams without collapsing into interference. EEVEE is a concrete attempt to make that happen.

The practical takeaway

EEVEE is not just another prompt-tuning variant. It is a test-time learning framework built around the reality that production data is heterogeneous, and that routing plus prompt adaptation may need to evolve together.

For engineers, the main lesson is architectural: if your agent learns online, you probably need some mechanism to separate task families before updating shared prompt state. EEVEE turns that intuition into a specific framework and shows measurable gains in multi-benchmark settings.

• It targets multi-dataset, real-world task streams instead of single-benchmark setups.
• Its router-prompt co-evolution is designed to reduce cross-dataset interference.
• The reported gains are strongest in heterogeneous evaluation, not just isolated benchmark learning.