A preprint from MIT proposes that AI agents built on different models stop talking to each other in words. In Swarm Telepathy: Prefill-Free KV-Cache Transfer Across Families (arXiv 2610.15095, dated October 10, 2026), authors at MIT CSAIL and the MIT-IBM Computing Research Lab describe SwaT, a small learned mapper that translates one frozen language model's internal key-value cache into another family's, so the receiver can continue from the sender's state without reading any text. They report that, combined with cache compaction, it beats text summaries by a mean of 40% in accuracy and a mean of 4 times in wall-clock speed.
The story spread on October 29 as "MIT builds a protocol so different AI models can communicate without words." That framing is close but loose: it is a research method with released code, not a standard or a product. Here is what it does, what the numbers mean, and where the limits are.
TL;DR: SwaT at a glance
| Question | Answer (per the paper and repo) |
|---|---|
| Who | Abdulrahman Alabdulkareem, Irene Tenison, Yang Zhang, Yada Zhu, Boris Katz, Dan Gutfreund; MIT CSAIL and MIT-IBM Computing Research Lab |
| What | A mapper that turns a sender LLM's KV-cache into a receiver LLM's KV-cache across model families |
| Why | Text is a narrow, slow channel for multi-agent systems; the sender already computed a richer internal state |
| Headline result | Mean 40% higher accuracy and 4x faster than text-to-text summaries (SwaT plus cache compaction) |
| Coverage | 17 benchmarks, 12 LLMs, 6 families |
| Training cost | Under 50M tokens, under 1 GPU-day; sender and receiver stay frozen |
| Mapper size | About 300M parameters in total |
| Code | GitHub repository with training and evaluation scripts |
| Status | arXiv preprint; no independent replication found |
Why not just send text?
Most LLM multi-agent systems work like a relay: one agent reads its inputs, writes a summary, and the next agent reads that summary. The paper's objection is that this is lossy and wasteful. A summary is limited by what its author chooses to write and by what the reader can reconstruct, and it costs twice: the sender decodes token by token, and the receiver must run a full prefill over the text before doing any work.
A bead waiting inside a side pocket, picturing a KV cache that stores a model's working memory
Internally, the sender has already built its KV-cache: every layer's view of every token it processed. That cache is the full state an agent needs to produce its next token. Earlier work showed that agents sharing one model backbone can exchange such latent states and carry more information per token than text. The new question is whether this works between a Qwen model and a Llama model, whose caches have different shapes, layers and tokenizers.
The authors lean on the Platonic Representation Hypothesis, the idea that models trained on the same world converge toward similar representations. If that holds, a cross-family handoff reduces to learning a mapping function.
How does SwaT work?
Per the paper and the repository, SwaT is a transformer mapper with blocks that each cross-attend to a group of the sender's cache layers and output a matching group of the receiver's cache layers. Both language models stay frozen; only the mapper is trained.
Two practical wrinkles are handled explicitly. Different families tokenize the same text differently, so positions and the causal mask are aligned through each token's character span. And positional encodings are removed from the sender's keys and reapplied for the receiver.
Training has two stages with two losses:
- Reconstruction. A normalized mean-squared-error loss pulls the predicted cache toward the receiver's own cache for the same text (5k steps in the repository's recipe).
- Receiver next-token loss. The receiver must answer correctly from the transferred cache in place of the text, with gradients passing through the frozen receiver into the mapper only (24k steps).
The default pair in the repository is Granite 3.3 8B as sender and SmolLM3 3B as receiver, and training uses two GPUs, one per model.
What did the experiments show?
The paper makes three claims, each worth reading with its caveat.
Retention across 17 benchmarks
A receiver reading SwaT's cache keeps over 90% of its own score with the real text on average, and over 100% when the sender is the larger model, per the repository. The paper's table of zero-shot retention shows a wide spread: for example Qwen 3 4B to Llama 3 8B averages 98.5%, Gemma 3 4B to Llama 3 8B averages 92.2%, and Granite 3.3 8B to SmolLM3 3B averages 143.2%, driven by a very large gain on an F1 metric. Averages hide that some pairs and benchmarks lose ground, especially out-of-domain short-answer tasks.
SwaT plus compaction versus text summaries
This is the 40% and 4 times headline. The authors combine SwaT with Attention Matching, a cache compaction method, and compare at matched budgets against text-to-text summaries on seven datasets such as QuALITY, QASPER, HotpotQA, MuSiQue, SQuAD, NarrativeQA and LongHealth. The speed claim covers both sender GPU time and receiver time to first token. The repository notes that the comparison averages three sender-receiver pairs, seven datasets and five budgets, and that its default configuration uses a weaker uniform compaction budget for receivers without an optimized one, so reproducing the exact gain on a new pair may differ.
Vision and language transfer
Three grippers placing different shapes into one shared tray, picturing agents handing off shared state
With a vision-language model as sender, SwaT gave a text-only receiver vision capability that exceeded text-to-text communication, even though the mapper only saw English text during training. The repository adds that Qwen3 passed its ability on Chinese tasks to Llama 3 the same way. That is the most surprising result and the one that most needs independent checking.
What does this mean for agent builders?
If you run multi-agent pipelines, the paper points to three places where cache handoff could help, all named by the authors: a child agent handing its parent a compacted cache instead of a summary, switching models mid-conversation without re-reading the whole context, and routers that read a query and then pass their cache to the chosen model rather than forcing a second read.
For anyone picking between agent designs today, our guides on agent memory systems that underperform naive retrieval, test-time memory evolution and recursive agent harnessing cover the text-and-memory side of the same problem. SwaT is a different bet: that the best memory to share is the model's own state.
What are the limits?
- Open weights only. SwaT reads and writes KV-caches, so it needs access to model internals. It does not work with closed APIs.
- One mapper per pair. The paper trains a mapper for each sender and receiver combination, though training is cheap at under a GPU-day.
- Preprint, small repo. The code is public but young; the repository showed a single commit and a handful of stars when we checked, and we found no independent replication.
- Interpretability. A text summary can be read, audited and logged. A translated cache cannot. For agent oversight, that is a real cost. Systems that need audit trails may prefer text even if it is slower; see our coverage of open-source governance layers for coding agents.
- Benchmark scope. The evaluations are question answering on documents and standard reasoning sets, not long-running tool-using agents.
- Safety. Hidden channels between models are harder to monitor. If you deploy agents that act on real systems, add controls that watch what they do, not only what they say. AgentBeam is the agent security platform from the explainx.ai team for stopping dangerous agent actions.
Is this really "from MIT"?
Yes, with the usual nuance. The paper lists MIT CSAIL and the MIT-IBM Computing Research Lab as affiliations, and the corresponding author uses an MIT address. It is a research preprint, not an MIT product announcement or a cross-industry protocol. The "Meta, Google and Alibaba" framing in some summaries refers to open models from those companies' families (Llama, Gemma and Qwen), which the authors used as test models; those companies were not involved.
How to try it
The SwaT repository on GitHub documents the steps. Clone it, install the pinned requirements, download the two models and datasets, then run scripts/exp1/run.py to train a mapper for the default Granite-to-SmolLM3 pair and evaluate it on the 17 benchmarks. A second script, scripts/exp2/run.py, reproduces the comparison against text summaries, and a notebook walks one sample through the three steps: the sender prefills, SwaT translates, the receiver answers without seeing the text. You need roughly two GPUs for the default run.
Bottom line
SwaT is a credible step toward agents that share state rather than prose, and the claim that a mapper under 50M tokens of training can bridge model families is notable. The 40% and 4 times figures are the authors' averages under specific budgets, and the interpretability trade-off is real. Treat it as a research direction to watch, and test on your own model pair before relying on it.
Related reading
- YC Labs agent swarms in Minecraft and Mindustry: GPT-6.1 Sol vs Opus 5.5
- Agent memory systems vs naive RAG: the memory tax paper
- Test-time memory evolution beats test-time training
- Recursive agent harnessing: Google Harness2 and JobBench
- Bernstein: open-source governance for coding agents
- OpenVLHarness: visual agent harness with multimodal memory
- Qwen3-8 Flash Next on a consumer GPU
Results are as reported in the October 2026 arXiv preprint and its repository and may change in later versions.