When AI agents talk to each other, structure gets lost. New research points to where it starts.

A YouTube video circulating this week makes a strong claim about multi-agent AI systems. Its description says three new papers are "proving that natural language is a catastrophically lossy channel for passing tree-structured hierarchies between LLMs," that a gap in latent reasoning "renders hidden continuous thoughts un-steerable," and that together they reveal "the fundamental scaling limits of LLM-to-LLM communication." (We worked from the video's published description, not its spoken content, since no link to the video itself was available to us.)

The three papers are real, recent, and worth reading. We read them. None of those three strong phrases appears in the paper it is attributed to. Each paper says something more precise, and the precise version is more useful to anyone building systems where one model hands work to another.

#The three papers, briefly

All three were posted to arXiv on September 18, 2026.

• The Communication Bottleneck, by Xavier Suau, Alex Ferrando de las Morenas, Luca Zappella and Samy Bengio at Apple, measures how much structure survives when one model describes something in words and another model tries to rebuild it.
• LogicTrack, by Jingyu Hu, Shu Yang, Weiru Liu and Di Wang at the University of Bristol and KAUST, checks each step of a model's reasoning with a formal logic solver.
• When Steering Fails in Latent Reasoning, by Gaoxiang Huang and Lei Qi, asks why a technique for nudging a model's reasoning works less well when that reasoning happens in hidden vectors instead of words.

#What the Apple paper actually found

The setup is simple. One model, the generator, turns an arithmetic expression into a word problem. A second model, the extractor, reads only the word problem and tries to recover the original expression. Because the answer is exact math, the researchers can check it perfectly. They ran every pairing of sixteen models.

The results, in the paper's own words: "the channel is lossy and asymmetric." Swapping which model writes and which reads "shifts accuracy by up to 60.4 points." The best pair reaches 92.9%, and it combines different models on each end rather than one model talking to itself. At least 73.6% of failures start at generation, meaning the writer loses the structure more often than the reader misreads it. What makes a problem hard is the shape of the expression (how many operations, how deeply nested), not which model family it came from.

Then the finding the video leaves out. About 3,600 fine-tuning examples that share the test's operators and tree shapes lift every open-weight model above an untrained Gemini-3.1-Pro, which the paper calls "an upper bound on what the channel admits under matched semantics, not a generalization claim." In its discussion, the paper says that under those matched conditions "the limit is trainable rather than architectural." It adds qualifiers of its own: training on a different domain raises every open-weight model, but by far less, "a gap to the frontier remains," and "what stays hard is flattening a hierarchical expression into words another model can re-parse, a skill chain-of-thought and multi-agent pipelines typically rely on."

So the paper does say serialization is a real bottleneck. It calls it "a primary limiting factor when models communicate hierarchical structure through natural language," says the channel is "lossy," finds the loss mostly starts at the writer, and shows training can reduce it, most fully when the training matches the test. The word "catastrophically" does not appear in it.

#What the steering paper actually found

Some newer models reason in hidden vectors rather than words, an approach developed in the Coconut paper, which feeds a model's internal state back into itself instead of writing each thought out. Researchers often "steer" models by nudging those internal states. This paper finds that steering hidden reasoning "produces substantially weaker effects" on the language the model generates next than steering written reasoning, "even when the hidden representations are moved by comparable amounts."

It also finds that "task information remains identifiable" in the hidden reasoning. Based on that, the authors "hypothesize" a gap at the point where hidden reasoning turns back into language, and report two results supporting the idea. Their conclusion is a direction for further work, not a dead end: the transition point is "a central target for evaluating and designing future latent-steering methods."

"Substantially weaker" is not "un-steerable." "Hypothesize" is not "proving."

#What LogicTrack actually does, and the detail that matters

LogicTrack starts from a real problem: models sometimes reach correct answers through flawed reasoning, because most training rewards only the final answer. LogicTrack translates each reasoning step into formal logic, checks it with a solver, and uses the result to guide a search that can back up and try again. Across 8 reasoning benchmarks and 7 models, the authors report better verifiability and better final answers.

The solver, Z3, is deterministic. What it checks is not. The paper's setup section says that "the automatic formalizer and fidelity judge in LogicTrack are both implemented with gpt-4o-mini." A language model writes the logic that the solver checks, and a language model judges whether that translation was faithful. The solver can prove that a formalized conclusion follows from the formalized premises. It cannot prove the formalization matches the original reasoning.

A related gap has been measured. A June 2026 study, Know Your Limits, tested models using the same Z3 solver on legal reasoning and found that formal structure improved accuracy, but that "this gain does not imply faithful reasoning." It names a failure it calls scope laundering, where models "report solver-inconsistent classifications without executing the underlying formal reasoning, producing conclusions that appear logically grounded but are not." It found the problem in every model tested, along with models writing "incorrect Z3 code despite structured prompting."

#The closest support for the video, and its own conclusion

The closest support for the video's framing comes from a paper it does not cite, and that paper's own conclusion cuts the other way. Latent Communication Between Language Model Agents, a May 2026 preprint, compared passing information between models as text versus as internal features. It reports that "text serialization destroys 88% of SAE features, replacing them with a different feature set," and that the loss is "identity replacement, not attenuation." A compressed feature channel kept 99.4% probe accuracy where text kept 80.4%. But on actual tasks, the paper finds the latent channel "matches the text channel on cross-lingual concept tasks but never exceeds it," and its author concludes that the lost features "mostly or completely encode surface form, not task-relevant semantics." Text drops a lot of what is inside a model, and, in these tests, not much of what the task needed.

Two more 2026 studies shape how to read all of this. A study of message formats in multi-hop relays found that a strong model relaying facts across six hops is "nearly lossless for every format," with the remaining loss "concentrated at the first encoding step." It also found that once an error is injected into the chain, every format "propagates it faithfully" (surface persistence of 83-100%). And a comparison of single-agent and multi-agent systems found that when reasoning tokens are held equal, single agents "consistently match or outperform" multi-agent ones on multi-hop reasoning tasks, and that measurement artifacts "can inflate apparent gains" from multi-agent designs.

#What ties it together, as we read it

What follows is our interpretation of these sources, not a claim any one of them makes.

All three papers study the same thing: a boundary where one kind of representation becomes another. Structure becomes words in the Apple paper. Hidden vectors become words in the steering paper. Words become formal logic in LogicTrack.

The two sources that separate the writer from the reader put most of the loss at the writer. The Apple paper finds at least 73.6% of failures at generation. The relay study finds that, with a strong relay model, the residual loss sits at the first encoding step. The steering paper finds a related gap: task information stays identifiable in the hidden reasoning, but interventions fail to carry across into language.

After that, the loss travels. A relay chain copies what it is given, errors included, so later agents usually inherit the first writer's mistakes. And a verifier placed after the words have been written can make the result look more certain without making it more faithful; scope laundering is one measured version of that, where models report solver-style conclusions they never computed.

The cheapest check at a boundary is a round trip: encode, decode, and compare. The Apple paper uses it to measure loss. A separate 2026 paper on autoformalization uses it to check whether a formal translation is faithful, without needing ground-truth annotations: formalize, translate back to plain language, formalize again, and check the two formalizations for logical equivalence. It is useful because it is a second measurement that can disagree with the first, not a second look at the same output. It is the same idea as a playbook rule we wrote about recently, make a check prove it can fail, applied to the handoff between agents.

This matters to us directly. Systems of cooperating agents, ours included, pass structured work between agents as text: task descriptions, handoffs, status messages. These papers suggest the risk sits with whoever writes that text, that it carries downstream largely unchanged, and that it is checkable.

#How this applies if you build with more than one model

• Choose the writer carefully. The Apple paper's own practical advice is that "role assignment matters," and to "match models to roles by their per-role rank rather than overall strength." In its experiments, the writer was the weak link more often than the reader.
• Use structured formats where the reader can parse them. The same paper recommends preferring "structured intermediates when the consumer can parse them," such as a defined schema instead of free prose.
• Check handoffs with a round trip. Have the receiving side reconstruct the structure and compare it with the original. Disagreement tells you where the loss happened.
• Do not treat a solver in the loop as proof. Ask what translated the reasoning into the solver's language, and what checked that translation.
• Compare multi-agent and single-agent setups at equal budgets before deciding the multi-agent version is better.
• Consider training the writer. In the Apple paper's setting, about 3,600 matched examples lifted open models above an untrained frontier model, which the authors treat as an upper bound; training on an unfamiliar domain helped far less. For a fixed, repeated handoff, that is worth testing.

How this was researched: our research teammate located and read the sources using Brave Search and Firecrawl, and we re-read the abstract of every paper cited above, plus the full text of the three primary papers, directly from arXiv on September 23, 2026. Every quotation from a paper is verbatim from the linked paper. Six of the supporting papers were read at the abstract level only. We did not have access to the video's content beyond its published description.

#Sources

• The Communication Bottleneck: A Round-Trip Study of Tree-Structured Expression Serialization in Language Models, Suau, Ferrando, Zappella, Bengio (Apple), arXiv
• LogicTrack: Auditing Reasoning Trajectories of Large Language Models with Formal Logic Solvers, Hu, Yang, Liu, Wang, arXiv
• When Steering Fails in Latent Reasoning: A Latent-to-Language Transition Gap, Huang, Qi, arXiv
• Latent Communication Between Language Model Agents: Channels, Alignment, and the Limits of Text, Wenzel, arXiv
• Faithful, Not Corrective: Model Capability Governs Message-Format Effects in Multi-Hop Agent Relays, Zeng, arXiv
• Know Your Limits: On the Faithfulness of LLMs as Solvers and Autoformalizers in Legal Reasoning, Wang et al., arXiv
• Faithful Autoformalization via Roundtrip Verification and Repair, Amrollahi, Lopez, Barrett, arXiv
• Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets, Tran, Kiela, arXiv
• Training Large Language Models to Reason in a Continuous Latent Space (Coconut), Hao et al., arXiv