Key and value caching improves interaction between AI models

According to VentureBeat, when transferring work from one language model to another via text, the first model must compress its knowledge into text, and the next must read it and reconstruct the information contained. This process may result in data loss and increased output time. The Cache-to-Cache (C2C) technique, proposed by researchers at Tsinghua University and other Chinese institutions, attempts to solve this problem by allowing models to communicate through internal representations stored in their key-value (KV) caches, rather than relying only on intermediate text. In experiments, C2C improved accuracy by 3.1-5.4 percentage points compared to text communication and reduced the latency between models being tested. For teams developing model routers or multi-agent systems, this means that the communication layer itself can be targeted for optimization. C2C also fits into a broader line of multi-model AI research aimed at allowing models to exchange internal representations directly, without forcing each transfer to go through text tokens. The work was published at ICLR 2026

, and in September the researchers announced plans to release an implementation of "agent-driven KV-Cache" along with a serving system. Text is a costly bottleneck between models. Multilingual AI systems come in different configurations. In collaborative systems, models take on different roles and exchange analyses, instructions, or partial solutions. In routing systems, the host switches between models with different capabilities and costs as the conversation or workflow progresses. Classic text communication adds overhead to the output of the language model. These systems typically rely on text tokens to transfer information between models. The researchers say this creates three problems. The first is information loss. The model represents context internally as high-dimensional numerical states. To communicate via text, she must compress part of this representation into a sequence of text tokens. The receiving model must then interpret this sequence and construct its own representation of what the first model meant, possibly losing information along the way. Another problem is that those

textual information may be ambiguous. The researchers illustrate this with the example of the Coder and Writer model modifying an HTML document. The encoder understands what a specific structural location in the document means, but his text instructions do not convey this information accurately enough. The writer is unable to place the requested content in the correct location. Textual communication between language models can cause ambiguity and confusion. Finally, text communication imposes significant costs on the output of an AI system. The first model must generate its message sequentially, token by token. These tokens are then added to the input of a second model, which must process a longer context before it can generate a response. The longer the gear, the more work both models have to do. In systems with long contexts or agent retransmissions, this communication overhead can quickly add up. C2C tries to avoid additional text generation and processing of the transmitted message by the Receiver by communicating through a representation that the models already create: the KV cache. When the language model first processes a request, it goes through the stage

"pre-training" that transforms input data into internal representations of keys and values. These views are stored in the KV cache and are reused when the model generates its response. The cached key and value states encode information that the model has learned from the context. Experiments have shown that the KV cache can be converted between different models without reprocessing tokens. The researchers first tested whether the KV cache could serve as a means of communication. Their experiments showed that information stored in the KV cache can be enriched without increasing the cache length, and that a cache created by one model can be converted into the representation space of another model. C2C builds on these findings. Both models process the same context. One acts as the “Divider”, and the other as the “Receiver”. The trained cache merge module maps the Sharer's cache to the Receiver's view space and then merges it with the Receiver's own cache. The trained gate controls which layers of the Receiver should receive additional information. In routing systems, this allows the Receiver to integrate information from the cache

a Sharing without the need for an intermediate text message. Both models still process the shared context to build their own KV caches. In collaborative systems, this creates another communication channel along with text. The researchers tested C2C on reasoning and knowledge tests including MMLU-Redux, OpenBookQA, ARC-Challenge, and C-Eval. With a fixed Qwen3-0.6B as the Receiver and three different Sharers, C2C increased the average Receiver accuracy by 9.6-11.9 percentage points compared to the Receiver running alone, outperforming text communication by 3.1-5.4 points. These results are benchmark results and not tests of production agent workloads. Latency measurements were taken with batch size 1 on a single Nvidia A100. Latency improvement varied significantly across model pairs. C2C was 3.46, 1.51, and 14.41 times faster than text communication across the three main Fissile configurations. The result was obtained 14.41 times with Qwen3-4B Base as Fissile; researchers say this model sometimes ignored text communication instructions and generated messages of greater length, making text basic

level is particularly slow. In one text communication experiment, the Sharer generated an average of 80 communication tokens. It took 1.312 milliseconds to generate these tokens. The resulting message also increased the number of tokens that the Recipient needed to process. In contrast, C2C only required about 90 milliseconds of cache merging and did not require text token generation. The technique also worked when the two models had different architectures or specializations. The tests included combinations of Gemma-to-Qwen, Qwen Math-to-Qwen, and Qwen Coder-to-Qwen. C2C outperformed text communication across all five heterogeneous and altered model configurations reported in the experiment. C2C does not require fine-tuning of any of the participating language models. The researchers freeze the Divider and Receiver and train only the cache merging module using a standard next token prediction task. However, cross-model communication requires engineering work. Different models may have different tokenizers, number of layers, and view sizes. C2C aligns tokens generated by different tokenizers and maps the corresponding layers to the transform

ra before merging their caches. Bridging training also has an initial cost. The team has released the C2C code and configurations on GitHub under the Apache 2.0 license, as well as pre-trained C2C fuser checkpoints on Hugging Face. One drawback is that since C2C needs to read, transform, and replace KV cache internals, it requires an output stack that exposes those internals. This makes it relevant today mainly for teams that control their own output stack, rather than for applications that communicate models solely through private APIs. Language models may not need tokens to communicate with each other. C2C fits into a broader line of research that questions whether text should remain the standard interface within multi-model AI systems. One example is Nvidia's research into KV cache transfer between models. When a system switches models during a long session, the new model typically must process the accumulated context and rebuild its cache. Nvidia instead maps the existing cache into the target model format. On compatible pairs of models, Nvidia researchers reported that this t

The technique worked 2.7-25 times faster than repeated pre-tuning. While Nvidia's technique transfers a full KV cache between the source and target models, C2C forces both models to process context and then merges their caches so that the Receiver can benefit from the other model's semantic representation. Another example in this area is RecursiveMAS, a multi-agent framework that replaces text messages with continuous hidden representations passed between agents. His experiments showed up to 2.4 times faster inference and a 75.6% reduction in token usage compared to his text recursive counterpart. The mechanisms differ, but they share the same basic bet: models can communicate more effectively when they don't have to translate everything into text first. At this point, C2C is a research product rather than a production architecture: it requires access to internal models, and its achievements have been measured against benchmarks rather than actual agent workloads in the business. The material was prepared by a neural network based on the original publication. AI may make mistakes in details (numbers, names, dates, quotes) - for important information

and check the original source. Snorkel AI Raises Valuation to $3.5 Billion Amid Data Demand SpeakON Unveils AI Magnetic Button for Voice Typing on iPhone Kyutai Releases Voice of Reason Model for Orally Solving Math Problems. Nokia opens access to AnyJev, a library for decision-making without training. OpenAI introduced GPT-6 Sol and Luna with new API pricing, reducing the cost by 50%.