Researchers Release C2C to Let AI Models Share Internal Memory Instead of Text

The benchmark gains are promising for multi-model systems, but the technique requires direct access to model internals and has not been tested on production agent workloads.

By 3 min read
Researchers Release C2C to Let AI Models Share Internal Memory Instead of Text
Researchers Release C2C to Let AI Models Share Internal Memory Instead of Text

Listen to this story

The audio brief

About 1:36
0:001:36
Read transcript
Researchers have released C2C, short for cache-to-cache, a method that lets AI models share internal memory instead of relaying information as text. In one reported experiment, that eliminated a handoff of about 80 generated tokens, cutting the relay from 1,312 milliseconds to roughly 90 milliseconds. The basic problem is that when one model passes work to another, it usually has to describe its understanding in tokens. The receiving model then reads that text and reconstructs the meaning, potentially losing information along the way. C2C uses the key-value, or K-V, cache—the internal states a model builds while processing a prompt. A trained cache-fusion module maps the first model’s cache into the second model’s representation space, then combines the two. The researchers froze both language models and trained only that bridge. In tests using Qwen3-0.6B as the receiver, C2C improved average accuracy by about 3.1 to 5.4 percentage points over text handoffs. The paper also reports an average 2.5-times latency speedup. But this is still a controlled benchmark result, across tests including MMLU-Redux, OpenBookQA, ARC-Challenge, and C-Eval—not a production-agent verdict. The code, configurations, and pretrained cache-fuser checkpoints are released under the Apache 2.0 license. For now, C2C is mainly suited to teams running their own inference stacks, because it requires direct access to internal caches and model-specific bridges. The key question is whether those gains survive real, messy agent workflows.

Story brief

3 key points

C2C is an inference-time bridge for passing one language model’s KV cache directly into another model, avoiding text-based relay tokens. Its researchers report 3.1–5.4 percentage-point accuracy gains and an average 2.5× latency improvement in controlled benchmarks, including cross-model pairings. The code, configurations, and pretrained cache-fuser checkpoints are Apache 2.0 licensed, but deployment requires access...

  1. 01

    One test replaced 80 generated communication tokens, cutting the relay step from 1,312 milliseconds to roughly 90 milliseconds.

  2. 02

    With Qwen3-0.6B as Receiver, C2C improved average accuracy by approximately 3.1–5.4 percentage points over text handoffs.

  3. 03

    Researchers froze both language models and trained only the cache-fusion bridge, reducing the method’s training requirements.

Researchers from Tsinghua University and other Chinese institutions have released Cache-to-Cache, or C2C, a method that lets language models pass information through internal memory states rather than generated text. In the reported tests, it beat text handoffs on accuracy and latency—but only in controlled benchmarks with access to the models’ inner workings.

The work targets a recurring inefficiency in systems that route work between models or assign them different roles. Normally, a first model turns its understanding into a sequence of tokens; the next model then reads those tokens and reconstructs their meaning. That relay takes time and can discard details embedded in the first model’s internal representation.

A relay without the message

C2C uses the key-value cache, or KV cache: the stored internal states a language model creates while processing a prompt and reuses while generating an answer. Both participating models process the shared context. A trained cache-fusion module then maps the Sharer model’s cache into the Receiver model’s representation space and combines it with the Receiver’s cache. A learned gate chooses which Receiver layers get that added information.

Diagram illustrating KV-cache transformation between language models.
The C2C experiments tested whether one model’s KV cache could be transformed into another model’s representation space without reprocessing tokens. Source: venturebeat.com.

The paper’s results are strongest as a proof of the communication idea, not as a deployment verdict. With Qwen3-0.6B fixed as the Receiver, C2C improved average accuracy by roughly 3.1 to 5.4 percentage points over text-to-text communication. The official ICLR abstract reports an average 2.5× latency speedup, while the more detailed tests reported substantially different gains across model pairs.

A bridge, not a drop-in feature

C2C was evaluated on MMLU-Redux, OpenBookQA, ARC-Challenge and C-Eval, including configurations that paired different model families or specialized models. The researchers froze both language models and trained only the fusion module, avoiding a full fine-tune of either participant. But a bridge still has to account for incompatible tokenizers, layer counts and representation sizes.

What teams would need

  • An inference stack that can read, transform and replace internal KV-cache states.
  • A trained cache-fusion bridge for the models they want to connect.
  • Validation beyond the reported academic benchmarks before relying on it for agent workloads.

That leaves it most relevant today to teams that operate their own inference infrastructure, rather than applications that connect closed model APIs. The researchers have released the code and configurations under an Apache 2.0 license, plus pretrained cache-fuser checkpoints. Whether the efficiency gains survive real, messy agent workflows remains the central unanswered question.

Sources

  1. proceedings.iclr.ccproceedings.iclr.cc
  2. venturebeat.comC2C replaces text handoffs between AI models | VentureBeat

Loading discussion...

YOUR READING SPACE

Notifications

Researchers Release C2C to Let AI Models Share Internal Memory Instead of Text | Superpower Daily