36 seconds · 4K · Recorded coding task
Fixing a Django bug with seven coding agents
Qwen3-8B produces the patch 4.41× faster with CacheBack than with written reports on this case. Both runs make the same one-line code change and pass all 88 tests.
The receiver asks for what it needs.
-CacheBack uses that request to select which internal state gets sent.
-Our simplest implementation of receiver-conditioning: robust and training-free.
Written messages between agents can lose evidence; passing their entire internal state becomes expensive. Receiver-conditioning lets the receiver describe what it needs, so the sender can select what to pass on. CacheBack is our simplest, robust, training-free implementation.
-On FanOutQA with Qwen 3 8B, CacheBack sends 75% fewer positions than full-state transfer. Compared with same-size text communication, strict accuracy improves by 14.7 percentage points and median completion is 3.2× faster.
-Multi-agent systems distribute large contexts across agents that communicate to solve a task. Text messages are compact but require decoding and may omit evidence the receiving agent needs. Recent latent communication instead transfers KV caches. This avoids text generation and can improve accuracy and latency. However, a full KV cache grows linearly with both the context an individual agent processes, and the number of agents that coordinate together.
-This raises memory and context costs, often far exceeding available GPU resources and context window sizes. Our key observation is that agents need only send what the receiving agent requires for its local task -- which we call receiver-conditioned communication. The receiver agent passes the sender a small description of its information needs, which serves to filter and compress the sender agent's KV cache.
-CacheBack is a simple, robust, training-free instance of receiver conditioning based on the sender's attention weights. On FanOutQA, CacheBack with Qwen 3 removes 75% of the state the agent would otherwise receive, improving accuracy by 14.7 percentage points and reducing median task-completion latency by 3.2× relative to text communication. We show comparable improvements across model families that span dense Transformers, Mamba-attention hybrids, and sliding-window attention.
-A KV cache stores intermediate state from the text a model has processed. Abstract from the published paper, by Rossi et al. CC BY 4.0; emphasis added.
-The receiver describes what it needs for its next task. CacheBack uses that request to select part of the sender’s internal numerical state, or latent state, to send back.
-Select state using
the request
Has the next task
Our simplest implementation.
Robust and training-free.
Uses attention to the receiver’s request to score sender positions, then selects a subset within the message budget.
-CacheBack selects positions using the sender’s attention to the receiver’s request. In the paper’s selected-embedding channel, the corresponding input vectors are sent and the receiver rebuilds its KV cache. A position is not an isolated fact, and an attention score is not a guarantee of relevance. The experiments use matching models; cross-model translation is outside this work. Read the method and limitations.
On FanOutQA, three agents read separate sources and send state to one answering agent. These curves compare accuracy and completion time across message budgets and text-sender sizes.
Higher is more accurate. Further left is faster. Each point is a measured setting; lines join the best observed tradeoffs within each method. Text points vary sender size; CacheBack points vary compression or message budget. The receiver stays fixed.
Reading r4, r8, r16: rX means keeping about 1/X of the sender’s sequence positions. For example, r4 keeps 25%, r8 keeps 12.5%, and r16 keeps 6.25%. Larger numbers mean more compression and a smaller message.
On LongBench v2 Easy, four agents read successive sections of a long document. A final receiver answers from the last handoff. Evidence from the beginning must survive the chain.
A relative budget uses the rX fraction above, so message size grows with the sender’s context. A fixed budget caps the number of message positions, as in the labels “32K fixed” and “64K fixed”.
Redrawn from the paper’s plotting data for Qwen and Nemotron. Each benchmark uses 50 tasks submitted together on eight H100s; completion includes queueing. Accuracy averages three receiver draws. Qwen uses a 0 to 1,000 s time axis, Nemotron 0 to 400 s; each model keeps its scale across benchmarks. Figures 5, 11, and 12 in the paper.
-About “94% CacheBack”: r16 retains one sender position in sixteen, removing 93.75%. The selected Qwen result above uses r4, or 75% fewer positions. Position reduction is not total GPU memory saved.
-Seven workers help a coordinator fix a Django bug. Compare latent handoffs with written reports.
36 seconds · 4K · Recorded coding task
Qwen3-8B produces the patch 4.41× faster with CacheBack than with written reports on this case. Both runs make the same one-line code change and pass all 88 tests.
Recorded model run
Three documents contain the booking, a change of location, and the new desk’s ID rules. The final agent must connect all three.
-Maya should collect her pass at Harbour Hub on Friday, and she should bring a passport as her ID.
-Maya should collect her pass at the assigned desk based on her reference J7, not at the Central Desk. She should check the Friday operations notice using her reference J7 to confirm the exact location. The ID she should bring depends on the desk where she collects her pass. If she is collecting at Harbour Hub, she must bring a passport, as a driving licence is not accepted. The name on the ID must match her booking, and the ID requirements for the specific desk apply.
Qwen3-8B · one A100 · r4 · one warm run per method. Times include three handoffs and final answer generation, excluding model loading, tokenization, and warmup. This recording is an example, not a benchmark. Raw recording · Setup
-Task details and recording to follow.
Task details and recording to follow.

Agents can share internal model state instead of writing reports. Sending all of it, however, overwhelms the receiver.
The receiver asks for what it needs. CacheBack uses attention to that request to select which state gets sent. Simple, robust, and training-free.
Three senders read separate sources; one receiver answers. Higher is more accurate; left is faster. CacheBack points vary message size; text points vary sender size. rX keeps 1/X of the sender’s positions: r4 keeps 25%.
Four agents read a long document in sequence, passing state to a final answering agent. Relative budgets (rX) grow with context; fixed budgets (32K, 64K) cap message positions. Stronger compression can reduce accuracy.
50 concurrent tasks on 8 H100s; accuracy averaged over three receiver draws. Completion includes queueing. Full setup and results in the paper.
+Bind a sender and receiver to matching models, then pass the receiver’s request to rcc.transfer. CacheBack is the default selector. Continue generation with your model’s native API.
Local Qwen 3 weights, using Hugging Face or vLLM.
Hosted chat APIs do not expose the required state.
import rcc
+ Use CacheBack
Install rclc, bind your agents, and pass the receiver’s request.
Code and documentationLocal Qwen 3 weights, using Hugging Face or vLLM.
Hosted chat APIs do not expose the required state.
import rclc
-sender = rcc.bind(
+sender = rclc.bind(
model, tokenizer,
messages=sender_history, backend="hf",
)
-receiver = rcc.bind(
+receiver = rclc.bind(
model, tokenizer,
messages=receiver_history, backend="hf",
)
-await rcc.transfer(
+await rclc.transfer(
sender, receiver,
"Who owns the Cedar booking?",
)
-inputs = receiver.pop()
Model, tokenizer, and histories loaded; run in an async function or notebook. Runnable quickstart
- THE PAPER
Receiver-Conditioned Latent Communication gives 94% CacheBack
Maximillian Rossi, Prajwal Raghunath, Haoqing Xuan, Yusen Zhang, and Eugene Wu.
Cite this work BibTeX
@misc{rossi2026cacheback,
+inputs = receiver.pop()
Model, tokenizer, and histories loaded; run in an async function or notebook. Runnable quickstart
THE PAPER
Maximillian Rossi, Prajwal Raghunath, Haoqing Xuan, Yusen Zhang, and Eugene Wu.
@misc{rossi2026cacheback,
title = {Receiver-Conditioned Latent Communication
gives 94\% CacheBack},
author = {Rossi, Maximillian and Raghunath, Prajwal
@@ -194,9 +129,9 @@ CacheBack
archivePrefix = {arXiv},
primaryClass = {cs.AI},
url = {https://arxiv.org/abs/2609.32046}
-}
+}