Why AI agents should stop thinking in words, why that terrifies people, and how a decipher system called Rosetta makes the illegible more auditable than English ever was.
Large-language-model agents are forced to serialize every thought and every message into human-readable tokens — a representation built for mouths, not matrices. This serialization tax is now measurable: current research systems that let agents exchange latent vectors instead of prose report 70–84% token reductions with higher task accuracy. Yet every such system ships as an opaque transport: the field's own 2026 survey finds no decoder, no observability layer, and no commercial deployment among ~20 latent-communication methods.
We propose Argot, a communication language for machine agents that is non-human-readable by design, and Rosetta, a first-class decipher system built before the language it decodes. Argot develops in rungs: a designed symbolic protocol (lossless, legible-on-demand by construction); learned vector messages carrying a superposition of candidate meanings; a phase-encoded channel in which combining two agents' messages amplifies the hypotheses they agree on and cancels the ones they contradict — consensus as interference; and shared latent state that updates counterpart agents without transmission. Every mechanism runs on commodity hardware. We adopt the discipline of quantum software — delay collapse, design the measurement — while claiming none of quantum computing's speedups. A prior-art review across five literatures finds each ingredient validated in isolation and the assembly unclaimed.
A modern language model does not think in words. Its native representation is a residual-stream vector of two to sixteen thousand dimensions — a point in a space rich enough to hold a paragraph of nuance, several competing interpretations, and the model's uncertainty about all of them, simultaneously. A token, by contrast, carries roughly 17 bits: one choice from a vocabulary of ~50,000 entries. Every time a model "speaks," it collapses a high-dimensional thought into a string of 17-bit choices. Every time another model "listens," it pays the compute to inflate that string back into vectors.
For a single model talking to a human, this is the correct design — humans read words. But multi-agent systems have quietly inherited it as an unexamined default. When agent A hands a plan to agent B, the plan is decoded token-by-token from A's latent space, transmitted as prose, then re-encoded token-by-token into B's latent space — a lossy round-trip through the narrowest representation in the entire stack. The message restates context both agents already share. It carries politeness neither agent needs. And in a pipeline of N agents exchanging M messages, the round-trip is paid N×M times. We call this the serialization tax.
The tax is not hypothetical. In one production incident that motivated this work, a multi-agent development platform's inter-agent chatter consumed credits so quickly that its operator disabled multi-agent mode entirely — throughput had to be sacrificed to make cost survivable. This is now a common story: the emerging category of token-compression middleware (§3) exists because inter-agent traffic is a recognized cost center.
The measured ceiling is far higher than compression of prose. Research systems that abandon prose altogether — exchanging KV-caches, hidden states, or continuous embeddings — report 70.8–83.7% token reductions with accuracy gains of up to 14.6%[7], 2× latency wins with 8.5–10.5% accuracy improvements[5], and communication outcomes up to 27% better than natural language at under a quarter of the compute[6]. The conclusion these numbers force is uncomfortable and liberating: most of what agents say to each other never needed to be words.
Quantum computing has a famous problem: the hardware is ahead of the software. Machines with hundreds of physical qubits exist; algorithms that make them useful mostly do not. The gap is so acute that the frontier of quantum engineering now uses AI to close it from below — DeepMind's AlphaQubit decodes surface-code errors with a neural network[27], and the 2024–26 Rigetti/Quantum Machines calibration program used reinforcement learning to tune control pulses to 99.9% single-qubit gate fidelity[28]. Hardware waiting for software.
AI has the mirror-image problem, and almost nobody names it: the software is strangling the hardware. Every deployed GPU spends a large fraction of its cycles round-tripping thoughts through human-readable serialization, because human language is still the de facto machine code of the agent era. The overhang is not in a dilution refrigerator in a lab. It is idling in every rack already deployed.
Collapse is the tax. Whoever collapses least, wins. Quantum algorithms attack the tax with interference — wrong answers cancel before measurement. Argot attacks it by abolishing forced measurement — nothing is serialized mid-pipeline.
The deep structural identity between the two fields is this: both are blocked on the same missing layer — a programming model for computation in superposed representations, where readout is expensive and the win comes from what you do before you look. A quantum register holds 2n amplitudes but yields only n classical bits when measured; the algorithm's art is arranging interference so the answer concentrates before collapse. A latent message holds a weighted mixture of meanings but yields a single reading when decoded to tokens; the agent system's art — entirely undeveloped today — is operating on the mixture before collapse. Rosetta (§6) is, in the precise sense, a designed measurement system.
We are careful about what carries over and what does not. High-dimensional real vectors genuinely support superposition: the Johnson–Lindenstrauss geometry of high-dimensional spaces admits exponentially many almost-orthogonal directions, and interpretability research has shown production models exploit exactly this, storing more features than dimensions in interfering superposition[26]. Interference is not quantum-exclusive at all — it is wave mechanics, the physics of noise-canceling headphones, and it is fully implementable with phase-encoded vectors (§5). What does not carry over is entanglement's non-classical correlations and the exponential state space at linear physical cost — and therefore no quantum speedup is claimed anywhere in this document. One of quantum's three powers we claim, one we engineer classically, one we analogize functionally. None we oversell.
A five-lane prior-art review (latent inter-agent communication; designed and emergent agent languages; vector-symbolic and phase-based architectures; quantum-inspired NLP; and the commercial landscape) evaluated the field against the six components of the proposed assembly:
| Component | Definition | Status (mid-2026) |
|---|---|---|
| A · Latent channel | Non-human-readable agent-to-agent transport in real use | Crowded research wave; zero products |
| B · Decoder | First-class decipher/observability system shipped with the language | Does not exist — named as the field's open gap |
| C · Superposition | Messages carrying multiple candidate meanings simultaneously | Fragments; never a designed inter-agent format |
| D · Interference | Phase-encoded consensus: agreement amplifies, contradiction cancels | Zero presence — research or commercial |
| E · Shared state | Tied latent state updating counterparts without messages | Near-neighbors exist (KV-cache fusion) |
| F · Productization | Commercially shipped, not paper-only | Every adjacent piece funded; the assembly, nobody |
The transport layer became a genuine research subfield in eighteen months. Cache-to-Cache fuses one LLM's KV-cache into another's through a learned projector, with public code[5]. Interlat has agents exchange raw hidden states as messages[8]. LatentMAS runs training-free pure-latent collaboration through shared latent working memory[7]. CIPHER transmits the probability-weighted average of all token embeddings — the sender's full belief distribution as one vector, the closest existing thing to a superposed message[4]. The theory community has proven continuous thought vectors can encode parallel breadth-first search frontiers[2] — and, in the spirit of honest accounting, that claim is contested[3].
Commercially, the market has funded every adjacent piece: KV-cache infrastructure at $24.5M[22], token-compression middleware through Y Combinator[23], quantum-inspired tensor-network compression at a $215M Series B[24], and an entire agent-observability category — every member of which decodes traffic that was never illegible in the first place.
The 2026 field survey is unusually direct: latent channels are "opaque — there is no natural language to inspect"; among ~20 catalogued systems it finds no decoder or observability layer, no phase or interference method, and no commercial deployment[9]. The decoder gap is treated by the safety literature as an emergency rather than a roadmap item: attack papers demonstrate invisible corruption of KV-cache handoffs precisely because nothing renders the channel legible[11]. Meanwhile the mathematics of interference-based consensus sits fully formed and unused in adjacent literatures: Fourier Holographic Reduced Representations encode symbols as phasors whose bundling is literally wave interference[14]; Kuramoto-oscillator networks solve constraint problems by phase alignment and anti-alignment[13]; complex-valued language encoders show synonyms phase-locking and ambiguity resolving by interference[15]. All of it inside single networks. No one has made two agents' messages interfere.
Two findings deserve special mention. First, the identifiability theorem behind Thought Communication proves that latent content exchanged between agents can be recovered and decomposed into shared and private components[10] — the mathematical foundation on which a decipher system can stand. Rosetta is not merely possible; it is provably possible. Second, in an irony we choose to read as an omen, the leading latent-transport codebase names its universal wrapper class RosettaModel — the transport wearing the name of the decoder nobody built.
The two open squares are B-as-product and D-at-all. They are also the two squares that make the rest safe and scientific, respectively. That is the assembly Argot claims.
Human-readability must not be the wire format — that is the serialization tax. But it must be one decode away, always, for any message, live or replayed. The decoder ships before the language. A latent channel without a decoder is a liability; a latent channel with a first-class decoder is more auditable than prose (§8).
Superposition is claimed and real (high-dimensional geometry). Interference is engineered (wave mechanics via phase encoding — no qubits required). Entanglement is analogized only (shared latent state; no non-classical correlations implied). Asymptotic quantum advantage is never claimed. Every sentence in this paper survives a hostile physicist.
Every mechanism runs on the GPUs and CPUs agents already run on. The project's premise is that the overhang lives in deployed hardware — it would be self-refuting to require exotic compute.
Every rung of the ladder has a numeric gate measured by paired runs against a prose baseline (§7). Claims that fail their gates are published as failures. The superposition-capacity literature is currently contested — a project like this earns trust by being the one that measures rather than asserts.
Message composition is defined tensorially (linear, associative) rather than ad hoc. This costs little today and keeps a door permanently open: languages with tensorial semantics compile naturally to quantum circuits (§9). Argot should run on GPUs today and be expressible on quantum hardware the day that matters — without redesign.
Argot is not one artifact but a ladder of four, each rung independently useful, independently testable, and strictly more expressive than the last. Rosetta rides alongside every rung.
A symbolic wire format for agent traffic: typed, compact messages (intent, operation, references, payload) with zero prose. Shared context lives in a content-addressed store — stated once, referenced forever by hash, never restated. Because v0 is deterministic, Rosetta v0 is a renderer, not a model: reconstruction is 100% faithful by construction. v0 is deliberately unambitious science and immediately valuable engineering — its target is the 30–50% of multi-agent spend that is restated context and conversational padding, before any learning enters the picture. It also has a second, subtler role: it is the schema that later learned layers must remain decodable into.
Communication adapters fine-tuned onto small open-weight models (the Coconut curriculum[1], applied to the channel rather than the chain of thought): the sender emits k continuous vectors in place of a prose message; the receiver ingests them through a learned projection. One vector message carries a weighted mixture of candidate meanings — the sender no longer commits to a single reading of its own uncertain state. Closed frontier models cannot participate natively (token-in/token-out APIs); the architecture therefore pairs a frontier orchestrator speaking v0 with open-weight specialists speaking v1 among themselves.
The scientific heart of the project. Hypotheses within a message are encoded as phasors — complex-valued components whose phase carries identity and whose magnitude carries weight, following the FHRR construction[14]. Message composition is constrained to norm-preserving (unitary-parameterized) operators. The payoff is a consensus mechanism with no analogue in current agent systems: when two agents' messages combine, hypotheses they agree on add in phase and amplify; hypotheses they contradict add out of phase and cancel. Agreement stops being a negotiation conducted in paragraphs and becomes a physical property of the channel. Kuramoto-oscillator results[13] and phase-locking language encoders[15] demonstrate the mechanics inside single networks; v1.5's contribution is placing them between agents.
Pairs or teams of agents maintain tied segments of latent working memory — the lineage of KV-cache fusion[5] and shared latent memory[7], extended from one-shot transfer to standing state. When one agent updates the shared segment, its counterpart's interpretations shift with no message sent. This is a functional analog of entanglement's signature — correlation without communication — and we are explicit that it is only an analog: implemented with ordinary memory, violating no classical bound.
Rosetta is the product the safety literature is asking for by name and the component the entire latent-communication field has skipped. It is a standalone system — not a feature flag — with five duties:
Render. Any Argot message, any rung, live or from archive, decodes to faithful English on demand. For v0 this is deterministic. For v1+ it is a trained decoder standing on the identifiability result[10], with reconstruction fidelity reported as a first-class metric — glosses carry calibrated confidence, and low-confidence decodes are flagged, never silently smoothed.
Log and replay. Every message on the wire is archived with its decode. Any past exchange can be replayed message-by-message — the flight recorder for agent systems.
Watch. Statistical anomaly detection over the latent channel (the LCGuard lineage[12]): distributional drift, adversarial steering directions, and traffic that decodes to something other than what its task context predicts.
Decompose. Separation of shared from private content in exchanged thoughts, per the identifiability theory — surfacing what an agent transmitted beyond what the task required.
Budget. Enforcement of channel-capacity budgets: the learned layers may not carry more undecodable capacity than a configured bound, measured adversarially (§8). Where the wire is allowed to be dense, its density is a number someone chose, not an accident.
Rosetta is deliberately sequenced before the learned language it decodes (roadmap, §10). A decoder built after a language is an interpretability chore; a decoder built before it is a design constraint — v1 training jointly optimizes task performance and decodability, so illegibility beyond budget is a training failure, not a discovery made in production.
Each experiment is paired-run by construction: identical tasks, identical models, prose channel versus Argot channel, blind quality judging. Gates are numeric and pre-registered in this document.
| Experiment | Question | Gate |
|---|---|---|
| E1 · Economics | Token and latency cost, v0 vs prose, on multi-agent pipelines | ≥30% token reduction at quality parity |
| E2 · Fidelity | Rosetta reconstruction accuracy per rung | 100% (v0, by construction); gloss accuracy reported with calibration (v1+) |
| E3 · Superposition capacity | Can one v1 message carry N hypotheses where prose needs N messages? | Measured capacity curve published, contested-literature methodology[3] addressed |
| E4 · Interference consensus | Does m₁ ⊕ m₂ amplify shared hypotheses and cancel contradicted ones? | Cancellation measured; consensus quality ≥ debate baselines[4] at lower cost |
| E5 · Adversarial legibility | Can a red team pass hidden content through the channel past Rosetta? | Hidden-capacity bound measured against steganography benchmarks[25] |
| E6 · Shared-state utility | Does v2 tied memory cut retransmission vs v1 messaging alone? | Measured delta on long-horizon collaborative tasks |
Everything publishes, including failures. If superposed messages do not beat sequential messages (E3), or interference consensus does not beat debate (E4), those are results — the field currently has assertions on both sides and measurements on neither.
The obvious objection to a non-human-readable agent language is the correct one: illegible channels are where bad behavior hides. The attack literature already demonstrates invisible corruption of latent handoffs[11], and the steganography literature shows models can develop covert channels inside innocent-looking prose[25] — a detail that matters more than it first appears.
Because the comparison point is not a perfectly transparent world. Prose channels only feel auditable: they are unstructured, unbounded, steganography-friendly, and audited in practice by sampling. Argot v0 is the opposite: a typed protocol with content-addressed references has almost no degrees of freedom in which to hide — every field means one thing, and deviation is a parse error. The learned rungs reintroduce risk, and the architecture spends its safety budget exactly there: decodability as a training objective, capacity budgets enforced adversarially, anomaly detection on the wire, and total logging with replay. The honest claim is not "Argot is safe because we added a decoder." It is: a designed latent channel with a first-class measurement system is more auditable than prose, not less — because auditability was engineered rather than assumed.
There is also a timing argument. The field is going latent regardless — a dozen transport papers in twelve months, the first commercial KV-cache infrastructure already funded. The realistic choice is not between legible prose and illegible vectors; it is between latent channels that ship with decoders and latent channels that do not. Building the decoder-first version is both the safety position and, not coincidentally, the position most legible to the AI-safety research community.
Principle 5 requires Argot's composition rules to be tensorial. The reason is a research program hiding in plain sight: the DisCoCat framework showed in 2010 that compositional grammar maps onto exactly the mathematics of quantum processes[17] — a lineage running from categorical quantum mechanics[16] to lambeq, a maintained toolkit that compiles sentences into executable quantum circuits[18]. Language whose semantics compose tensorially is, in a precise sense, already written in the grammar quantum machines natively speak.
Today this is a design constraint costing almost nothing. Its long-horizon payoff is an existence-proof milestone: compile a fragment of Argot v0 to a quantum circuit via lambeq and execute it — even as a toy. Related far-horizon markers exist: entangled multi-agent RL already demonstrates message-free coordination through shared quantum state in simulation[19], the literal endpoint of the v2 analogy. No timeline is attached to any of this and no claim depends on it; the annex exists so that when quantum hardware matures, Argot requires a compiler, not a redesign. An agent language that runs on GPUs today and compiles to quantum circuits tomorrow is a sentence no other project can currently write.
| Phase | Deliverable | Gate | Compute cost |
|---|---|---|---|
| 1 · Argot v0 | Protocol spec, reference implementation, paired-run harness | E1 | Local, ~$0 |
| 2 · Rosetta | Renderer, log/replay, watch — standalone service | E2 (v0) | Local, ~$0 |
| 3 · Argot v1 | Communication adapters on small open weights + jointly trained decoder | E2–E3 | Local toy; ~$100–150 rented GPU-weekend at 1.5B scale |
| 4 · v1.5 phase channel | Phasor encoding, unitary composition, interference experiments | E4 | Reuses Phase 3 rig |
| 5 · v2 + integration | Shared latent memory; proxy mode for real agent stacks | E5–E6 | Local, ~$0 |
| 6 · Annex | lambeq compilation existence proof | Circuit executes | Simulator, ~$0 |
The economic frame is arbitrage, not replacement. Frontier models keep the role they are irreplaceable in — broad, high-stakes reasoning at the orchestration layer. Argot targets the other 80% of agent computation: high-volume, narrow, repetitive inter-agent traffic that never needed frontier breadth or human-readable serialization. The commercial surfaces fall out of the ladder in order: a wire-compression proxy whose value is a measurable percentage of a customer's token bill (Phases 1–2); Rosetta as an observability product for a field that has literally none (Phase 2 onward, and independently sellable); and the research program itself (Phases 3–4), whose headline artifact — agents that reach consensus by interference, measured — is the kind of result that outlives any single product.
The entire program through Phase 4 costs less than a dinner for two in compute. The expensive ingredient was never the hardware. It was noticing that the hardware was already enough.