MIT: AI agents share KV-cache instead of text and run 4x faster

When several AI agents split one task, they have to pass context to each other. One finishes its piece, and the next has to pick up from there. Usually the first agent writes a text summary, and the second reads it from scratch. MIT researchers have proposed a different approach. Their architecture, SwaT (Swarm Telepathy), passes the KV-cache between models instead of a summary. That is, it passes context that has already been processed. Compared with text summaries, SwaT combined with cache compression raised answer quality by 40% on average and speed by a factor of four.

Why summaries are expensive

The summary approach looks simple, but you pay twice.

The first cost is compute. The sending agent spends time and tokens writing the summary. The receiving agent then processes that text from zero, as if seeing it for the first time.

The second cost is loss. A summary is always shorter than the original. A small detail that seemed unimportant to the sender may be needed by the receiver two steps later. It can no longer be recovered.

In long agent chains, this adds up. The more handoffs there are, the more redundant work is done and the more the original picture is distorted.

What gets passed instead of text

The KV-cache is a language model's internal memory of what it has already read. As the model processes text, it stores intermediate data for each token: keys and values. Thanks to them, the model does not need to recompute the entire context each time it generates a new word. In essence, it is a set of notes the model has written for itself.

The idea behind SwaT is to hand those notes directly to the next agent. The receiver then does not need to reread any text, and nothing is lost in a human-readable summary.

There is a catch. Every model has its own internal format: number of layers, dimensions, the way tokens are represented. So one model's cache cannot simply be dropped into another. According to the authors, SwaT handles this even for models from different families. This is the least trivial part of the work, and it is what makes the method applicable to mixed teams of agents.

Cache compression is used on top of this. A full cache takes up a lot of memory, so it is compacted. The results the authors report were obtained with exactly this combination.

What the experiments showed

The comparison was against the most common way of passing context: text summaries. Benchmark results:

• Answer quality: on average 40% higher than with text summaries. • Speed: approximately four times higher. • Cross-family operation: the receiver does not have to share the sender's architecture. • Vision transfer: information from a VLM (a model that processes images together with text) was passed to an ordinary text model that cannot see images itself.

The last point is perhaps the most intriguing. The text model received not a description of the image but the internal representation built by the VLM. This opens the door to specialization. One model looks at images, another reasons over the result cheaply, and neither spends resources translating what it saw into words.

What this means for engineers

For developers of agent systems, the takeaway is simple: a summary between agents is not the only option, and often not the best one. If your agents run on models where you have access to internal states, exchanging the cache can cut latency and compute costs.

There are caveats. This is academic work on arXiv (2610.15095), not a finished product. The figures are averaged across a set of benchmarks, and on your task the result may differ. In addition, the KV-cache is usually not available through the public APIs of closed models. So this approach is easiest to apply with open models that you run yourself.

Still, the direction is clear. If agents exchange the model's memory rather than words, multi-agent systems will become faster and more accurate. And perhaps a new norm will emerge: teams of different models, each with its own specialization, working as a single whole.