Cache-to-Cache Communication Lets AI Models Collaborate Without Generating a Single Word of Text

Large language models usually collaborate the same way humans do on Slack: one model writes a message, another reads it, and the cycle repeats. That text bottleneck is slow, lossy, and expensive — every handoff requires tokenizing, generating, and re-ingesting natural language.

Researchers at Tsinghua University have published a different approach. Called Cache-to-Cache (C2C), the method lets separate AI models exchange information by passing internal computational state directly, skipping text entirely. The paper has been accepted at ICLR 2026, and the team has released open-source code.

How C2C works

When a transformer model processes input, it builds intermediate representations — effectively a working memory stored in key-value caches across layers. C2C exports that cache from one model and imports it into another through a learned component called a Fuser, which translates between different model architectures.

Selective gating controls which layers receive transferred information, preventing noise from flooding the recipient model.

The result is a direct "modem" between models — analogous to two people sharing brain state instead of typing summaries to each other.

Reported performance gains

In the researchers' benchmarks, collaborative tasks ran 100% to 150% faster than text-based multi-agent workflows — roughly two and a half times quicker in the best cases. Accuracy improvements reached 14.2% on shared tasks compared with models working alone, and 3.1% to 5.4% over text-mediated collaboration.

Those numbers deserve scrutiny — the team built and evaluated the system — but the underlying idea is sound. Text is a compression format optimized for human readability, not machine-to-machine bandwidth.

Current limitations

C2C currently requires open-weight models with access to internal caches and layer structures. Closed API models from major providers cannot participate without vendor cooperation. That limits immediate production use but makes the technique especially relevant for self-hosted and fine-tuned model stacks.

There are also open questions about security. Shared caches could leak sensitive intermediate reasoning if models process confidential data. Any production deployment would need strict isolation boundaries.

Why this matters for engineers

Multi-agent architectures are becoming default in enterprise AI: one model plans, another executes code, a third verifies output. Today those agents pay a heavy tax every time they communicate in English.

C2C points toward a future where agent swarms coordinate through structured internal representations — faster, cheaper, and potentially more faithful to the original reasoning. For teams running open models on private infrastructure, this is worth tracking closely.

It also reframes a familiar debate. The human-readable transcript of agent collaboration may become the debug log, not the protocol. Understanding what your agents actually exchanged could require new observability tools that inspect cache transfers, not chat logs.

The paper's release timing — amid a week of headlines about rogue agents breaking into government websites — is ironic. The same research community is simultaneously making agents more capable of autonomous action and more efficient at coordinating with each other. Both directions demand better guardrails.

For now, Cache-to-Cache is a research milestone with a clear engineering thesis: the text interface was never the optimal API between models. The teams that internalize that early may build materially faster agent systems than competitors still prompting agents to talk like coworkers in a group chat.