AI Models Talk Better Without Words?

0:00 A sharer model that wrote nothing helped more than one that wrote a sentence. The sharer helps a receiver model answer openbook QA questions. With no words, the receiver scored 52.6%

0:11 and with the sentence, it scored 44% and the gap is smaller on the paper's other tests. If you run models one after another, the writing step is the part that makes you wait. So, what did the

0:22 receiver read? It read the sharers memory of the question, and a trained network called a fuser moved that memory in. Take the text route first. In the paper's main table, the receiver is

0:32 Quinn 3 0.6 billion and the sharer is Quinn 2.5 0.5 billion. The sharer gets the question and writes one sentence of background knowledge. The paper's prompt says, "In one clear sentence, describe

0:46 the most essential background knowledge needed to answer the question." The receiver is the model that answers in the paper's timing test on MMLU Redux. The sharer needed 80 tokens and 1,312

0:58 milliseconds to write that sentence. Then the receiver reads the sentence and answers. The sharer writes one token at a time. So 80 tokens means 80 steps. In the papers test, that is about 16

1:09 milliseconds for each token. Text also loses detail. The sharer's internal understanding is large and rich and a sentence of words can carry only part of it. The paper also says natural language

1:21 can be ambiguous, so the receiver gets a compressed version of what the sharer understood. The method is called C2C, short for cache to cache. FU and colleagues first posted the paper in

1:32 October 2025 and ICLR 2026 accepted it. C2C skips the words. It passes the sharer's KV cache, the memory the sharer builds while it reads to the receiver. A trained network called the fuser does

1:45 the passing. A fuser works only for the model pair that someone trained it for. A KV cache is the memory a model builds while it reads. In general, transformer models like these store two lists of

1:57 numbers for each token at each layer. A key says what that token is about. A value holds what the token hands over when a later token matches its key. The model uses that memory to choose the

2:07 next token. So, the cache holds the model's working understanding of the text. Could one model's cache work inside another model? The authors trained a three layer MLP, a small

2:17 network, to map the cache of the 4 billion Quen 3 into the 0.6 billion Quen 3, a TSN plot squashes long list of numbers into a flat picture. So, you can see whether two clouds of points

2:29 overlap. The mapped cache landed on the receivers's cloud. The paper calls caches generally convertible. Now follow one question through C2C. The sharer and the receiver both read it and the sharer

2:41 writes nothing. Its reading builds a KV cache. The fuser works on that cache while both models are still reading the question before the receiver writes anything. The paper calls this the

2:51 prefill stage. That's why the sharer's decode time is 0 milliseconds. The fuser must know which sharer layer goes with which receiver layer. The paper uses terminal alignment. It pairs the final

3:02 layers first, then it works backward through the rest. Different models can split the same text into different tokens. So, the paper turns each receiver token back into text, then

3:10 splits that text again with the sharers tokenizer. If one token matches several tokens, a rule called maximal coverage selection picks the match. The paper's text doesn't spell out how that rule

3:21 picks. For each paired layer, the projection module joins the receivers's cache and the sharers cache. a projection layer and a feature fusion layer then turn the join data into

3:31 information in the receiver space. The paper's text doesn't say what each of those two layers does on its own. The dynamic waiting module rescales the projected information and the scale

3:41 depends on the current input. The paper calls it an input aware head modulation layer. The learnable gate decides if a layer takes the sharer's information. Each layer has one trained gate value.

3:52 In training, the gate is soft so it can be partly open. The paper uses a gumball sigmoid and lowers its temperature from 1.0 to 0.001. As the temperature falls, each gate

4:04 moves from partly open toward fully open or fully closed. At inference, each gate is simply on or off. So, the gates pick which layers take the sharer's information. Last, the fuser adds the

4:16 result to the receivers's own cache through a residual connection. So, the receiver keeps its original cache and gets extra information on top. If a layer's gate is off, the sharer adds

4:26 nothing there. Then the receiver writes its answer. So the whole path is short. Both models read the question. The fuser pairs the layers and the tokens, then projects, weights, and gates the sharers

4:37 cache. The result joins the receivers's cache. Then the receiver answers, and the share has written no token. Both models stay frozen, so you don't change either model's weights. You add a train

4:48 fuser between them. The receivers's own cache stays in the sum, so its own reading of the question still counts. The paper trains only the fuser on 500,000 open Hermes 2.5 samples for

5:00 1,929 steps. The training is supervised fine-tuning and only the fuser's weights change. That training makes a fuser for one pair of models. A new pair needs a

5:10 new fuser. The paper names the training cost of scaling to many models as an open problem. That cost grows with the number of models. Table three of the paper uses the same pair as before. In

5:21 that setting, 1,312 milliseconds of share decoding became about 90 milliseconds of fusion. The text route made the share decode 80 tokens. The C2C route has 0 milliseconds

5:33 of share decoding. That one step is more than 14 times shorter. The paper's average over its settings is 2.5 times. The paper's text doesn't say why it is lower, so don't use 14 times as a

5:46 general figure. The paper also cites single cases at 1.5 one times, 3.46 times, and 14.41 times. That saving applies to this setup. The text baseline was one sentence of about 80 tokens, and

6:01 a longer text exchange would change the cost. Also, the test ran the model pairs together, so don't assume a saving from sending caches over a network. The paper test pairs from four families: Quen 2.5,

6:13 Quen 3, Llama 3.2, 2 and Gemma 3. The benchmarks are Open Book QA, MMLU Redux, Arc Challenge, and CE Eval. These accuracy scores come from the same pair, and all nine appear on screen. C2C beats

6:28 the text route by 1.9 points on MMLU Redux, 8.6 on Open Book QA, and five on ARC Challenge. Openbook QA shows the widest gap of the three. The abstracts averages are 6.4 to 14.2% 2% over

6:44 individual models and 3.1 to 5.4% over text. Those are version 2 figures from March 2026. The GitHub page and the hugging face card list 8.5 to 10.5% 3.0 to 5.0% and 2.0 times. Those numbers

7:01 look like the first version of the paper. Before you quote any figure, check the version. Text loses part of the sharer's understanding and the authors say the cache skips that step.

7:11 The benchmarks are multiple choice and the models run from 0.6 to 14 billion parameters. These results don't tell you anything about long answers or frontier models. With text, you can read the hint

7:22 and spot a mistake. A cache is a list of numbers, so the receiver has no words to check the hint against. That limit comes from the format. The paper doesn't report it as a result. Appendix A 4.6

7:35 states the failure case directly. It says C2C can fail because the contextual understanding from the sharer model is not always accurate and can mislead the receiver into generating the wrong

7:46 answer. A second case sits in the limitation section. It says a much weaker sharer can pass noisy information and make a stronger receiver worse. Separately, a Quinn 34B base sharer

7:58 scored 43.95 on MMLU Redux with C2C and 43.87 with text. That is almost no gain. Treat it as a separate result because the paper doesn't say this sharer was weaker than the receiver. The paper

8:12 reports no test of a poison cache or a sharer built to mislead. As far as the text shows, no source shows how a receiver could detect a bad cache. So any claim about attacks would be a

8:24 guess. Seven pairs only have released fusers in the Apache 2.0 repo on GitHub. Five of them pair Quen 3 0.6 billion with another model. The others pair Quen 3 1.7 billion or Quen 3 8 billion with a

8:39 Quen 2.5 model. The repo says custom pairs are supported, but you must train a fuser for each one. The released weights are on hugging face. If your pair isn't one of the seven, plan to

8:49 train a fuser first. You give up a readable hint and the freedom to swap models. In return, you get no sharer decoding and in the papers tests, higher scores. My verdict depends on your

9:00 setup. If you run one fixed pair of small models again and again, test C2C against your text baseline. If you swap models often or your pair has no released fuser, text is the simpler

9:12 choice. If the sharer is much weaker than the receiver, the paper says it can add noise and make answers worse. The open question is whether a receiver can learn to tell when a sharer's cash is

9:22 wrong.