TFlow: AIs Communicate by Rewriting Each Other's Weights, Not by Talking

Two AIs usually "chat" the way humans do: one serializes its thoughts into text, sends it, and the other parses the text back into internal representations. A new paper argues this is a wasteful detour — and proposes that the best way for AIs to communicate is not to speak, but to directly modify each other's brains.

The Waste of Text-Based Communication

Current multi-agent systems (MAS) make Agent A generate a verbal message and stuff it into Agent C's context window. This causes three problems:

1. Huge token consumption: internal computation is serialized into hundreds of tokens that the receiver must re-encode from scratch. 2. KV-cache bloat: every extra agent and turn linearly grows memory usage and latency. 3. Information bottleneck: things the AI "knows" but cannot verbalize — probability distributions, subtle feature correlations — get flattened in text.

With a three-agent system (Qwen3-4B) on GSM8K: a single agent outputs ~1337 tokens; adding two text-communicating teammates pushes total consumption to 5381 — 4x more, with KV-cache operations as the real performance killer.

TFlow: Compiling Thought Into Weight Perturbations

TFlow's core idea is elegantly simple: don't send text — compile the sender's hidden states into a fine-tuning patch of the receiver's weights.

The pipeline:

1. Three agents share one frozen base model (Qwen3-4B), each with a different role prompt — Agent A analyzes reasoning types, Agent B retrieves domain knowledge, Agent C answers. 2. Senders A and B read the question and run a frozen forward pass — no output text, only per-layer hidden states. 3. A trainable Parameter Generator maps these hidden states into low-rank LoRA matrices — essentially "fine-tuning patches." 4. The two senders' LoRA patches are fused through a learnable gating mechanism and temporarily injected into Agent C's linear layers during generation. 5. After the answer is generated, patches are discarded; Agent C reverts to the original frozen model.

Crucially, patches are generated per question, on the fly — not a fixed pre-trained LoRA. Role prompts influence patches naturally through hidden-state variation, with no special handling per role combination.

The Numbers

Across five benchmarks (MMLU, GSM8K, MATH, HumanEval+, MBPP+), three-agent TFlow:

Versus a single agent:

• Accuracy up 7.13–8.53 percentage points
• Total token consumption down 5%–33% (weight-space guidance yields more concise reasoning paths)

Versus text-communicating three-agent systems:

• Token consumption down 71%–83%
• End-to-end inference 2.3–4.6x faster
• Accuracy gap within only 1.3–4.5 points

The exception is HumanEval+ (code): long text context gives the model more "generation compute," which benefits code generation. TFlow loses ~10 points there but uses 72% fewer tokens.

Notably, on MMLU TFlow uses 998 tokens (vs. 1079 for a single agent) while gaining 8 accuracy points — the perturbation doesn't just accelerate, it changes how the model thinks: more precise, less verbose.

Are the Patches Really Instance-Specific?

If the generator produced nearly identical patches for all inputs, TFlow would just be static fine-tuning. The paper runs three analyses:

• Hidden-state analysis: on 20 GSM8K + 20 MBPP+ instances, within-task cosine similarity of last-layer hidden states is ~0.75, cross-task ~0.35. The aggregated vector c consumed by the generator shows even lower cross-task similarity — the generator amplifies task differences. The generator relies mostly on layer 29 (deep) hidden states, suggesting high-level reasoning representations are the key information source.
• LoRA tensor analysis: TSNE visualization of 120 instances shows LoRA patches cluster cleanly by task, with fused patches moderately overlapping both senders' contributions.
• Ablation: swapping patches between questions drops MMLU accuracy from 66.97% to 47.57%; the base model alone scores 58.99%. A wrong patch is worse than no patch — patches are precise prescriptions, not optional seasoning.

What This Means

1. Thought need not become language. Forcing internal reasoning into text loses information; passing representations directly as weight perturbations is feasible, faster, and cheaper. 2. Temporary adaptation vs. permanent learning. Patches are discarded after use — no lasting memory, no "learning bad habits." Collaboration gains are strictly scoped to the current task. 3. Low training cost. Only a lightweight 2-block transformer generator is trained: 8 hours on a single RTX PRO 6000 with 32k samples. All LLM backbones stay frozen. 4. Patch interpretability. Patches from different tasks form geometric clusters, potentially letting us study how one agent's reasoning strategy or another's knowledge manifests in weight space — nearly impossible with free-form text.

A Feynman-Style Review

Humans use language not because it's optimal, but because it's the only channel we have. AIs share no such limitation: their "minds" live in the same mathematical space. Forcing them to communicate via text is like two programmers in adjacent rooms exchanging code by carrier pigeon.

TFlow's elegance is that it doesn't try to make AI more human-like — it accepts that AIs aren't human and asks what communication is most natural for them. The answer: directly modifying each other's computation graph.

It's not perfect — code generation favors text, patch injection hurts batching, and the receiver's architecture must be known and fixed. But these are engineering issues, not fundamental flaws. The deeper implication: future AI collaboration may look less like "conversation" and more like "merging" — multiple AIs temporarily fusing into one larger computational unit, then separating when the task ends. Science-fiction-sounding, but on math and coding benchmarks, it already works.

Reference paper

Wenrui Bao, Huan Wang, Jian Wang, Zhangyang Wang, Kai Wang, Yuzhang Shang. "Good Agentic Friends Do Not Just Give Verbal Advice: They Can Update Your Weights." arXiv:2605.13839, 2026.