The short version Mostik’s latent bridge lets a 753B model pass hidden states to a 4B model without completed text.
The company reports 80% accuracy and 20-times faster performance, but has not published a reproducible benchmark.
Latent communication could cut inference costs while creating an internal channel that engineers cannot yet inspect.
Mostik’s latent bridge lets AI models exchange internal representations instead of sentences.
The mechanism makes sense.
The spectacular speed and cost claims still need receipts.
Mostik wants the giant model to think and the tiny one to type.
In its disclosed setup, a 753B-parameter model reads the problem, passes hidden states to a 4B model, and lets the smaller one answer.
The company says this retained 80% of the frontier model’s accuracy.
No completed message passes between them.
They communicate beneath the text layer.
If this works, the largest model needn’t generate every token.
It does the hard computation, hands over an internal representation, and leaves the smaller model to face the user.
We get cheaper, faster answers.
The machines get a private channel we can’t yet read.
That made me put down the limoncello.
A sentence is the receipt Three technical terms keep landing in the same acronym soup.
Weights are fixed values learned during training that shape how a model processes input.
Hidden states, or activations, are temporary numerical representations created for a specific prompt.
Tokens are the text pieces eventually shown to us.
Mostik says its protocol transfers hidden states while the original models remain frozen.
Weights define each model’s internal space; the hidden state holds whatever is currently on the chopping board.
The sentence arrives later, plated and suspiciously clean.
A normal text handoff loses information.
The first model builds an internal representation, then autoregressive decoding converts part of it into tokens.
The receiving model gets only those words and encodes them into a new internal state.
Anything excluded from the sentence disappears.
Calling hidden activity “thought” goes too far; none of this proves consciousness or a private monologue.
Still, prose-only communication resembles handing over the carbonara without the timing, pan temperature, quantities, or exact moment the eggs nearly became breakfast.
Text also creates a serial compute bill.
According to the XKV paper, autoregressive decoding sits on the critical path: one model writes token by token, then another processes the message before starting.
Across a long agent workflow, every handoff becomes another tiny airport security line.
The sharing model must compress its information into a discrete message without seeing the receiver’s state, so it can’t tailor the transfer to what the receiver already understands.
XKV’s researchers developed latent-cache protocols that move internal information before a finished paragraph exists.
Mostik makes the same complaint.
Its launch material argues that completed text discards the computation behind the words, so its bridge connects models beneath the language interface.
The bridge must reconcile alien coordinates Here is Mostik’s disclosed mechanism.
A frontier model processes the problem and creates hidden states.
The protocol captures part of that representation, though Mostik keeps the tensors and layers secret.
An undisclosed mapping must align the information with the smaller receiver’s internal space.
The receiver uses that signal during inference, then generates the answer.
Sasha Malysheva says neither original model is fine-tuned.
Joined inference produces one output without a completed textual handoff.
Malysheva put the bet plainly in her launch post: we think it's the wrong question. here's the one we pose: why does a frontier model have to generate your answer at all, when the only thing you need from it is the reasoning?
That mapping has a brutal job.
Model families may use different dimensions, layer structures, and tokenizers, while separate training histories can place similar concepts in unrelated coordinates.
Two Italian kitchens can both make excellent carbonara, yet “the second drawer beside the stove” means a whisk in one and seventeen dead batteries in the other.
Copying equivalent positions would be useless.
The bridge must preserve task-relevant information, convert it into something the receiver understands, and avoid wrecking the state already built. “Telepathy” sells conference tickets.
Representation alignment is the engineering problem.
Mostik has disclosed almost nothing about the conversion.
We don’t know the mathematical mapping, which tensors cross, or when the transfer occurs during inference.
Public material leaves reliability across other model families, tasks, and non-text modalities unresolved.
Security-sensitive deployments add another question: an internal representation may carry harmful instructions that never become words.
The alignment method is the invention, and outsiders can inspect only its box.
Mostik chief scientist Stanislav Smirnov told WIRED: There seems to be no appropriate mathematical language yet.
Frankly, that increases my confidence in the team.
Anyone calling this math a tidy solved problem would trigger my founder-grade PowerPoint allergy.
The broader research direction has public support.
XKV also freezes participating models while training a translator, but uses KV caches and information from both participants to create receiver-compatible memory.
Mostik describes a one-way flow from frontier model to smaller model.
XKV makes cross-model latent communication technically plausible.
Its published work cannot validate Mostik’s undisclosed implementation.
A giant reads while the cheap model types Mostik’s disclosed setup gives the large model the reading job and the edge-class model the typing.
Parameter count is a crude capability proxy, but the economics make sense.
Answer generation requires sequential decoding: another pass through the writing model for every output token.
If the frontier system contributes useful internal information and leaves that loop to a compact receiver, the expensive network spends less time producing prose.
Final quality depends on how much knowledge survives translation and whether the sender must be consulted again.
Translator overhead also belongs on the invoice.
The company says the hybrid retained 80% of the frontier model’s accuracy but hasn’t identified the evaluation.
WIRED described the result as halfway between the large and small models.
These may come from separate tests, but no public benchmark reconciles them.
Accuracy means different things across coding, reasoning, and question-answering, while a blended score can hide catastrophic failures in one category behind another’s strength.
For now, that percentage lives on Mostik’s scoreboard.
I’ve seen the size effect on my desk.
In my measurements, a 20B-parameter gpt-oss model generated about 74 tokens per second on my M3 Max; the 120B version managed roughly
51.
Both were fully resident in memory under the same setup.
The smaller model also processed prompts faster and produced its first token sooner.
This says nothing about Mostik’s translator.
It does explain why I want the compact model typing.
I ran those measurements on August 25,
2026.
Founder hobbies get strange after enough years.
My RTX 5060 Ti with 16GB of memory was running ComfyUI, leaving Ollama about 150MB of VRAM.
The 20B language model therefore ran entirely on the CPU.
Apparently even GPUs can set boundaries.
Mostik also claims its bridged system ran 20 times faster, but the published comparison omits hardware and workload.
We don’t know whether “faster” means lower time to first token, higher generation speed, or lower end-to-end latency.
A reported demonstration priced the hybrid at one-twentieth the cost of the full frontier model, but the accounting remains private.
The sender’s runtime matters, along with translator training and any repeated