🤖 AI

RIZZ: Routing Interactions to Near Zero-Interference Zones for Continual Adaptation of Black-Box Agents

RIZZ is a continual adaptation framework for black-box language model agents that mitigates interference in nonstationary environments by dynamically routing interactions to specialized memory branches and updating them only through verifier-gated feedback.

Original authors: Sonali Goel, Pranav Vaidhyanathan, Lucas Schorling, Natalia Ares, Maike Osborne

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Sonali Goel, Pranav Vaidhyanathan, Lucas Schorling, Natalia Ares, Maike Osborne

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, frozen genius (a Large Language Model) who is incredibly smart but cannot learn new things by changing their own brain. They are like a master chef who has memorized every recipe in the world but is forbidden from writing down new ones or changing their cooking style.

Now, imagine this chef is working in a busy restaurant where customers keep ordering different dishes: sometimes Italian, sometimes coding puzzles, sometimes medical advice, and sometimes travel planning. If the chef tries to remember everything in one giant, messy notebook, they will get confused. A tip for making pasta might accidentally ruin their recipe for coding a website. This is called "interference," and it makes the chef worse over time.

RIZZ is a new system designed to help this frozen genius adapt without breaking their brain. Think of RIZZ as a super-organized butler and filing system that stands between the chef and the customers.

Here is how RIZZ works, using simple analogies:

1. The "Zero-Interference Zones" (The Branches)

Instead of one giant notebook, RIZZ sets up many small, separate workstations (called "branches").

The Analogy: Imagine a library where books aren't just thrown on one shelf. Instead, there is a "Cooking" room, a "Coding" room, and a "Travel" room.
How it helps: When a customer asks for a coding solution, the butler (the Router) sends them straight to the Coding room. The chef only sees the notes and tips from that specific room. This means a mistake made while cooking pasta won't accidentally make the chef forget how to write Python code.

2. The Smart Butler (The Router)

Every time a new question comes in, RIZZ's "butler" looks at it and decides which workstation to use.

The Analogy: If a customer says, "I need a recipe for a tomato sauce," the butler recognizes this belongs in the Cooking room. If they say, "Fix this broken code," the butler sends them to the Coding room.
The Magic: If the butler sees a question that is totally new (like a customer asking about a new type of alien cuisine), it instantly builds a new workstation just for that. If two workstations are doing the exact same thing, the butler merges them to save space.

3. The Strict Gatekeeper (The Verifier)

This is the most important rule in RIZZ: You can't just write anything down.

The Analogy: Imagine the chef tries a new recipe. If the customer says, "Yum, that's great!" (a high score), the butler writes that recipe down in the permanent book for that room. But if the customer says, "This tastes terrible" (a low score), the butler throws the note away or puts it in a "Do Not Do This" folder.
Why it matters: This prevents the system from learning bad habits. It only keeps the "wins" and the "lessons learned from failures," ensuring the chef gets better, not worse.

4. The Bounded Briefcase (Prompt Compilation)

The chef can only carry a limited amount of information in their head at one time (this is called the "context window").

The Analogy: RIZZ acts like a personal assistant who packs a briefcase for the chef before they start cooking. The assistant only packs the most relevant notes from the specific room the chef is in. If the briefcase is too full, the assistant drops the least important notes first, ensuring the chef never gets overwhelmed or forgets the current task.

What Did They Find?

The researchers tested this system on several "challenges" (benchmarks) where the chef had to handle a stream of different tasks:

Better than doing nothing: The chef with the RIZZ butler got significantly better at tasks over time compared to the chef working alone.
Cheaper and Faster: Other systems tried to keep all the notes in one giant pile, which made the briefcase too heavy and expensive to carry. RIZZ kept the briefcase light and focused, saving money and time.
No "Brain Freeze": When the chef switched from a math problem to a coding problem, RIZZ kept the memories separate. The chef didn't get confused or forget how to do the previous task (a problem known as "catastrophic forgetting").

In Summary

RIZZ is a way to make a smart, unchangeable AI get smarter over time by organizing its memories into separate, specialized rooms, letting it only keep the good lessons, and packing the right notes for the job at hand. It's like giving a genius a perfect filing system so they can learn from their experiences without getting overwhelmed or confused.

Technical Summary: RIZZ (Routing Interactions to Near Zero-Interference Zones)

Problem Statement

Large language models (LLMs) are increasingly deployed as long-lived, compound agents that must adapt to non-stationary streams of users, tasks, and feedback regimes without access to model weights (black-box setting). Existing adaptation strategies face three primary limitations in this regime:

Single-Prompt/Global Memory Optimization: Methods that optimize a single prompt or maintain an undifferentiated global memory struggle with catastrophic interference, where lessons from one task family contaminate behavior on unrelated tasks.
Search-Heavy Approaches: Techniques relying on repeated rollouts or extensive search are computationally expensive and often impractical for online, context-budget-constrained scenarios.
Lack of Selectivity: Current systems often fail to distinguish between reusable procedural structures and task-specific noise, leading to either brittle performance or wasteful isolation.

The core challenge is to enable an agent to improve continuously from experience (online adaptation) while explicitly controlling interference between task families, all without updating the underlying frozen model parameters.

Methodology: RIZZ Framework

RIZZ (Routing Interactions to Near Zero-Interference Zones) is a continual adaptation framework that shifts the locus of learning from model parameters to an external, routed memory system. The system operates on a frozen black-box LLM and relies on three core mechanisms: Hierarchical Routing, Branch-Local Memory, and Verifier-Gated Evolution.

1. Adaptive State and Hierarchical Routing

Instead of a single global memory, RIZZ maintains a Branch Bank ( $B_t$ ), where each branch acts as a "zero-interference zone" or a specialized expert memory.

Labeling: For each incoming query, a lightweight router (using an LLM judge) assigns a hierarchical label consisting of a function ( $f$ ) and an application ( $a$ ).
Snapping and De-duplication: The system snaps new labels to existing branches using embedding similarity for the application ( $\tau_{snap} = 0.92$ ) and Jaccard token overlap for same-function siblings ( $\tau_J = 0.40$ ). This prevents fragmentation while allowing specialization.
Dynamic Spawning: If no compatible branch exists and capacity allows, a new branch is spawned. If a branch becomes redundant, it is merged or pruned.
Routing Logic: The router selects the branch that best matches the query's function and application, ensuring that related interactions are grouped together.

2. Branch-Local Memory Substrates

Each branch $b$ contains multiple memory types:

Episodic Memory: Stores verifier-approved input/output examples.
Procedural Memory: Stores compact IF-THEN rules distilled from successful batches. Rules are weighted by helpful/harmful counters based on verifier feedback.
Failure Memory: Stores substantive wrong answers as "common mistakes" (anti-patterns) to prevent repetition, kept local to the branch to avoid overgeneralization.
Scoped Context: Retrieves session-specific evidence filtered by metadata scope.

3. Verifier-Gated Memory Evolution

Memory updates are strictly gated by a deterministic verifier (e.g., fuzzy ratio, exact match, code execution).

Write Policy: Only interactions that pass a verifier-dependent threshold are written to durable memory.
Rule Promotion: Successful interactions can be distilled into procedural rules; failures are retained as anti-patterns.
Quarantine: Low-reward or off-centroid interactions are quarantined or discarded to prevent contaminating the branch.
Prompt Compilation: A bounded prompt compiler assembles retrieved material (scoped context, episodic examples, rules, mistakes) into a prompt within a fixed token budget (e.g., 64K). Lower-priority blocks are dropped first to ensure graceful degradation to the frozen baseline rather than context overflow.

Key Contributions

Task-Agnostic Routing Framework: RIZZ formulates black-box adaptation as an online decision problem where a frozen model adapts solely through external state. It discovers specialist memory branches online without ground-truth task IDs or pre-specified taxonomies.
Compact Branch-Local Memory: Introduces a hierarchical routing mechanism that combines output-shape guards, embedding-based snapping, and Jaccard de-duplication. This keeps related experience together, limits cross-task interference, and allows dynamic branch creation and merging.
Verifier-Gated Evolution: Memory updates depend entirely on reward validation. This ensures that only verified, useful interactions update the memory, while failures are stored as concrete anti-templates. A budget-aware compiler ensures the system remains cost-efficient.
Efficient Empirical Performance: RIZZ achieves high accuracy across streaming adaptation, sequential continual learning, and long-term conversational memory benchmarks while remaining significantly cheaper and more token-efficient than heavier memory baselines.

Experimental Results

The authors evaluated RIZZ on four benchmarks using Claude Haiku 4.5 as the frozen base model:

TRACE (Sequential Continual Learning): RIZZ improved the average reward by +6.9 percentage points over the Frozen baseline and +7.6 points over AMem. Crucially, while the ACE baseline collapsed (0.047 reward) due to context window overflow on long-input tasks, RIZZ maintained stability by keeping the playbook compact (stabilizing around 10–15K tokens) and limiting branch counts (48 total, 31 active).
StreamBench (Online Interleaved Streams): RIZZ improved by +3.3 percentage points over Frozen and +2.2 points over AMem, with a lower total cost ($7.37 vs. $7.99 for Frozen). It successfully concentrated traffic into high-volume specialist branches (e.g., a clinical diagnosis branch handling 43% of traffic).
LongMemEval-S (Conversational Memory): RIZZ achieved the highest average reward (0.484), significantly outperforming AMem (0.322) and Frozen (0.202). It excelled in multi-session and temporal reasoning tasks by allocating distinct branches to different conversation sessions, whereas ACE failed due to context window exhaustion.
$\tau$ -Bench (Tool-Use): RIZZ improved the ReAct agent's pass@1 from 0.352 (Frozen) to 0.400, outperforming ACE (0.370) and AMem (0.303) with minimal cost increase.

Ablation Studies: Removing procedural memory, forcing single-branch routing, or disabling anti-fragmentation mechanisms resulted in measurable performance drops, confirming the necessity of the branch structure and verifier gating.

Significance and Claims

The paper claims that RIZZ demonstrates that continual adaptation for black-box agents can be achieved effectively without fine-tuning or unbounded context growth.

Interference Control: By routing interactions to near zero-interference zones, RIZZ resolves the stability-plasticity dilemma at the memory level rather than the weight level. It allows the agent to compound knowledge where structure recurs (e.g., repeated output formats, domain policies) without contaminating unrelated tasks.
Operational Efficiency: Unlike baselines that suffer from context collapse or high token costs due to massive global playbooks, RIZZ remains operationally lightweight. It degrades gracefully to the frozen baseline when context budgets are tight, rather than failing.
Practicality: The framework is designed for the regime where adaptation must occur online under strict context budgets, making it suitable for real-world deployment of compound AI systems.

The authors conclude that RIZZ points toward a future where compound AI systems utilize curated, routed, and auditable memory substrates for continual adaptation, rather than relying on ever-growing, undifferentiated transcripts.