Back

06/11/2026

Beyond Text: MIT’s Swarm Telepathy Research and the Future of Multi-Agent AI

An MIT preprint lets AI models from different families pass their KV cache instead of text. What SwaT reports, its limits, and what LOGIQ is evaluating.

Most multi-agent AI systems today work like a relay of written notes. One agent reads a long document, writes a summary, and passes it on. The next agent reads that summary from scratch before it can do its part. Every handoff throws away detail that did not make it into the text, and every receiving model repeats work the sender has already done.

A new preprint from researchers at MIT CSAIL and the MIT-IBM Computing Research Lab tests a different kind of handoff. Instead of passing prose, one model passes its internal working state to a model from a different family. This article explains what the researchers did, what their numbers do and do not show, and how LOGIQ plans to look at the idea.

Key takeaways

  • Swarm Telepathy: Prefill-Free KV-Cache Transfer Across Families (SwaT, arXiv:2610.15095) was submitted on October 10, 2026. It is a preprint and has not been peer reviewed.
  • A small trained mapper converts one model’s key-value (KV) cache into a cache that a model from another family can use, so the receiver does not have to process the original text again.
  • In the authors’ tests, SwaT with cache compaction was on average about 40% more accurate than text-summary handoffs and about 4x faster on the parts of the pipeline they timed.
  • It needs open model weights, internal cache access and a trained mapper for each model pair. It does not connect closed services such as ChatGPT and Claude.
  • LOGIQ has not adopted SwaT. We are considering an isolated proof of concept on local open-weight models.

What a KV cache is, and why passing it helps

When a large language model reads its input, it computes a set of intermediate values for every token, called keys and values. These are stored in the KV cache, and the model uses them for everything it generates afterwards. Building this cache is known as prefill, and for long documents it is a large share of the cost and of the delay before the first word of the answer (time to first token, or TTFT).

Models from the same family can sometimes reuse each other’s caches. Models from different families, such as Granite, Llama, Qwen or Gemma, organize these values differently, so normally the receiver must read the text again and build its own cache.

SwaT trains a mapper of about 300 million parameters for each sender and receiver pair. The mapper translates the sender’s cache into the receiver’s format, and the receiver starts answering from it directly. Both language models stay unchanged. According to the paper, training a mapper takes fewer than 50 million tokens of English text and less than one GPU-day. To keep the transferred cache small, the authors combine SwaT with a cache compaction method called Attention Matching.

What the researchers report

The authors evaluate 12 models from six families on 17 benchmarks. On those benchmarks, a receiver that reads a SwaT cache keeps more than 90% of the score it would reach by reading the original text itself.

The headline comparison is narrower. For three sender and receiver pairs, seven datasets and five size budgets, SwaT with Attention Matching is compared against the usual approach, in which the sender writes a text summary of the same size budget. Averaged over these runs, SwaT scored about 40% higher. This is a relative gain; the overall scores in the paper rise by roughly 17 points on average. The roughly 4x speed figure covers sender GPU time and the receiver’s time to first token, not a full end-to-end production workload.

The paper also reports a cross-modal result. Gemma 3 vision-language models looked at an image and wrote a short caption. A text-only receiver that got the transferred cache answered visual questions better than a receiver that only got the caption. On one pair, the average score rose from 21.1 to 41.6. The receiver did not gain general vision skills, and on benchmarks that need fine image detail it did not consistently beat the vision model that sent the cache.

How new is this?

The SwaT authors describe their method as the first cross-family KV-cache transfer that allows prefill-free communication. Readers should treat that as the authors’ claim. A related preprint, HeteroFold (arXiv:2609.32259), was submitted two weeks earlier and also describes prefill-free KV-cache transfer between model families. The two papers use different methods and evaluations, and neither has yet been through peer review.

Limitations, security and auditability

This research does not mean AI agents can read each other’s minds, and it does not show a 4x improvement for any real system, including LOGIQ’s. Several limits matter before anyone uses the idea in practice:

  • White-box access only. The method needs open weights and direct access to the model’s internal cache. Hosted APIs do not expose this, so it does not apply to closed services such as ChatGPT or Claude.
  • One mapper per pair. Each sender and receiver combination needs its own trained mapper. With many model families, the number of mappers grows quickly.
  • Single handoffs. The paper studies one transfer at a time. Chains of handoffs, or merging messages from several agents, are left for future work.
  • Runtime support. The public implementation uses PyTorch and Hugging Face models. Common serving runtimes do not offer this kind of cache exchange out of the box.
  • Hidden content. The authors note that a transferred cache may carry information beyond what is written in the sender’s text, and they call for research on auditability and safety. A cache can’t be read and approved by a person the way a message can, and it can hold confidential context the sender never meant to share.

What LOGIQ is evaluating

Agents in our Relay Zero architecture currently hand work to each other through explicit text messages. Each message can be read, reviewed and stored, and that record is part of how we approve changes and show what was done. We are not changing that.

What we are considering is a small, isolated research proof of concept between open-weight models on our own hardware, for example on our MS1 server with Ollama, where it may be possible to build the cache access SwaT needs. If we run it, we will compare it with our current text handoffs on:

  • time to first token and total latency
  • answer accuracy on our own internal tasks
  • GPU and memory use
  • traceability: whether we can still explain and audit what was handed over

Human-readable approvals, review records and operational evidence will stay in text whatever the results. At most, a cache handoff could become an extra fast path next to the written record, never a replacement for it.

Sources