PAPER DEEP DIVE
Large Language Models Do Not Always Need Readable Language
Large language models (LLMs) are commonly prompted and interfaced with human-readable natural language, even when the intended reader is another model. This paper investigates whether semantic information can be encoded in compact, non-standard textual forms that sacrifice human readability while remaining recoverable by LLMs. We refer to this class of model-centric textual representations as BabelTele, approached here not as a fixed protocol but as an empirical probe into LLMs' capacity to generate and interpret such representations. Through readability diagnostics, model likelihood measures, human questionnaires, and downstream task evaluations, we find that BabelTele can substantially depart from ordinary natural language while preserving core semantics for instruction-tuned LLMs. As a task-agnostic representational paradigm, BabelTele demonstrates high information density, maintaining 99.5% semantic fidelity even when the text volume is condensed to 27.9% of its original length. We further evaluate its semantic robustness in cross-model transfer, agent memory, and multi-agent communication. Results suggest that BabelTele can reduce context overhead while generally maintaining reliable downstream performance, although its effectiveness depends on the compressor-reader pair and task setting. These findings indicate that human readability, natural-language typicality, and model-side semantic recoverability can be partially decoupled, opening a path toward model-native representations in future exploration of LLM systems.
One-sentence summary
The paper removes human readability as a requirement for intermediate language and asks models to produce dense, cross-lingual symbolic text for other models; its reported operating point retains about 27.9% of the source tokens while preserving 99.5% semantic fidelity on the paper's aggregate evaluation.
1. The problem is not merely summarization
Large language models normally receive instructions, exchange context, and return results through natural language. That interface grew out of communication between people, so it carries an implicit constraint: intermediate text should remain grammatical, use familiar words, and expose enough surface structure for a human to inspect it. This paper argues that the constraint may be unnecessary when the text is produced only for another model. A model can preserve entities, numbers, negation, conditions, and event relations through multilingual word roots, abbreviations, arrows, mathematical symbols, and compressed relational notation even when the resulting string is difficult for people to read.
The proposed direction is called BabelTele. It is not a fixed cipher designed by the authors, a modified tokenizer, or a separately trained compression network. It is an empirical investigation of model-centered text representations elicited through prompting. Given source text $x$, a compressor $C$ produces a discrete text representation $z=C(x)$. The relevant objective is not whether $z$ resembles an ordinary essay. It is whether a reader model $R$ can complete the original task under the semantic condition $R(C(x)) \approx R(x)$.
This target differs from ordinary summarization. A summary is still judged partly by whether a person can skim it efficiently, so it tends to preserve natural-language word distributions and visible discourse structure. BabelTele deliberately relaxes those preferences. The string becomes a transport format for task-relevant meaning rather than a document that a person should read from start to finish. The authors do not claim that all language models have discovered one universal latent code. Their narrower claim is that overlapping pretraining exposure to multiple languages, source code, mathematics, tables, and factual relations may create enough shared structure for some representations to transfer across models.
Long contexts, agent memory, and multi-agent systems make the issue practical. Meeting transcripts, repository snapshots, tool traces, and long-running conversations are repeatedly inserted into model contexts. Their natural-language form contains substantial redundancy. If the only consumer is another model, preserving human syntax may consume tokens without preserving more task-relevant evidence. Yet compression is valuable only if the answer, relation, or constraint remains recoverable. The paper therefore evaluates length, downstream accuracy, cross-model transfer, and inference cost together instead of presenting compression ratio as the sole result.
The argument also avoids treating unreadability as an intrinsic benefit. A string can be unreadable because it is efficiently encoded, because it is lossy, or because it is simply malformed. Readability metrics alone cannot distinguish those cases. The paper uses low human readability and high language-model perplexity as evidence that the surface distribution has changed, then relies on downstream question answering to ask whether useful semantics survived. This separation is the central experimental move.
2. Metrics and what the reported numbers mean
Suppose the source contains $N_x$ tokens and the compressed representation contains $N_z$ tokens. The token-retention ratio is $r=N_z/N_x$, and the corresponding token reduction is $\delta=1-r$. At $r=0.279$, the representation retains 27.9% of the input tokens, so $\delta=0.721$: 72.1% of the source tokens have been removed. This ratio describes length, not semantic preservation, and must be paired with a task score before it supports any fidelity claim.
For a question $Q$, let $A(x,Q)$ be the accuracy of a reader given the original text and let $A(z,Q)$ be its accuracy given the representation. An aggregate relative-retention score can be written as $A_{\mathrm{ret}}=A(z,Q)/A(x,Q)$. On a single item, the reader's decision is $F(z,Q)=\operatorname{Acc}(R,Q,z)$. The compressor receives $x$ but not $Q$: compression happens before the question, options, answer, or evaluation prompt are introduced. This task-agnostic construction matters because it prevents the compressor from selecting only the evidence that one known question requires.
Human readability is measured on a different axis. If a readability function is denoted $D_{\mathrm{human}}(\cdot)$, the paper's descriptive pattern is $D_{\mathrm{human}}(z) \gg D_{\mathrm{human}}(x)$ while the downstream behavior can remain close to $F(x,Q)\approx F(z,Q)$ on selected tasks. These statements are not contradictory because they measure different properties. The first measures familiar English vocabulary and syntax; the second measures whether a prompted model can recover enough entities and relations to answer.
Cross-model experiments must distinguish the producer from the consumer. If model $C_a$ produces a representation and reader $R_b$ answers from it, a useful transfer signal is that $F(C_a(x),Q)$ remains competitive with the original-context score even when $a\neq b$. Same-model compression and reading can be explained by private shortcuts or prompt-specific behavior. A cross-model matrix provides stronger evidence of partial shared structure, although it still does not establish a universal protocol.
3. Method: prompt-elicited semantic collapse
BabelTele rests on three principles rather than a long training pipeline. First, omnilingual lexical selection allows the compressor to draw on Chinese, English, German compounds, Japanese kanji, and Latin roots when a wording preserves the target meaning with fewer tokens under the active tokenizer. Second, symbolic collapse turns connectors, emotions, qualifiers, and logical relations into operators, arrows, emoticons, brackets, or punctuation. Third, recoverable semantic density asks the representation to keep the entities, quantities, polarity, conditions, and event structure needed by a reader, even when the prose is no longer fluent.
The prompt describes the audience as another capable language model and explicitly relaxes single-language grammar. It also asks the compressor to retain information without loss while using the shortest practical representation. This creates a deliberate tension between density and recoverability. BabelTele is the family of outputs produced under that tension. It is not arbitrary noise, because the model is still instructed to preserve meaning, but it is not a formal reversible code either.
flowchart LR
X["Source document x"] --> C["Zero-shot compressor C"]
C --> R1["Relax human readability"]
C --> R2["Choose tokens across languages"]
C --> R3["Collapse relations into symbols"]
R1 --> Z["Discrete representation z"]
R2 --> Z
R3 --> Z
Z --> K["No external codebook"]
Z --> T["No gradients, new tokens, or tokenizer edits"]
K --> READ["Heterogeneous reader model"]
T --> READ
READ --> DOC["Document question answering"]
READ --> MEM["Long-term agent memory"]
READ --> TEAM["Two-agent communication"]
READ --> REPO["Chunked repository context"]
Compression is performed before the downstream question is visible. The compressor sees only the source passage or document. This is the practical meaning of the paper's task-agnostic claim: no task-specific supervision enters the compression prompt. It does not mean that every representation is equally good for every task. A document representation may preserve the passages needed for one question while omitting detail needed for another, so task-agnostic generation still requires task-level validation.
The paper's photosynthesis example illustrates the surface style. A short natural-language explanation is transformed into 11 tokens from a 45-token source, using fragments, arrows, and relational cues rather than complete sentences. A human sees many nonstandard combinations, but the model can still recover the roles of light, water, carbon dioxide, energy conversion, and oxygen release. This example explains the visual form of BabelTele; it is not the main quantitative evidence.
Figure 1: The paper contrasts BabelTele with natural-language representations, emphasizing the gap between low human readability and model-readable semantics.
Figure 2: The photosynthesis micro-example compresses 45 tokens to 11 while retaining relational cues instead of ordinary sentence syntax.
A possible explanation is that language models learn relations that cut across language, code, formulas, and formatted data. When the prompt permits prose to disappear, a model can expose some of those relations as symbols rather than reconstructing a human-facing sentence. The paper presents this as an empirical phenomenon, not as a mechanistic account. It does not identify the internal circuits that make cross-model recovery work, and it lists the lack of a mechanistic explanation as a limitation.
No external codebook is supplied to the reader. The output must carry enough context to be interpreted, which distinguishes the setup from secret-key compression. No gradients are required, no special vocabulary is added, and the tokenizer remains unchanged. The positive consequence is that BabelTele can be explored through ordinary black-box APIs. The negative consequence is that performance depends on the prompt, model version, tokenizer, and compatibility between producer and reader. A representation that works exceptionally well inside one model pair cannot be assumed to work unchanged outside that pair.
BabelTele is also not lossless in the information-theoretic sense. The experiments use question-answering accuracy and downstream behavior as proxies for recoverability; they do not require exact document reconstruction. Therefore the aggregate claim of 99.5% semantic fidelity should be tied to the evaluated task distribution. It is not a guarantee that any document compressed to 27.9% of its tokens will preserve 99.5% of every fact, caveat, or relation.
4. Readability, language-model probability, and semantic recovery diverge
The first controlled study uses ten QuALITY passages, with three multiple-choice questions per passage, for 30 question instances. Each passage has three versions: the original text, a natural-language summary, and BabelTele. The summary and BabelTele are both generated by Gemini 3.1 Pro, and generation is repeated to reduce dependence on a single sample. The study then measures readability, base-model perplexity, and question-answering performance with both human and instruction-model readers.
Higher Dale-Chall scores indicate text that is harder for an ordinary reader. The original passages average 10.28 with 35.97% difficult words. Natural-language summaries move to 13.51 and 56.34%, while BabelTele reaches 16.70 and 80.19%. BabelTele is therefore not simply a shorter English summary. Its vocabulary and syntax are farther from familiar prose than the summary baseline, which is consistent with the intended use of multilingual fragments and symbolic relations.
| Input form | Passages | Dale-Chall score | Difficult words | Interpretation |
|---|---|---|---|---|
| Original | 10 | 10.28 | 35.97% | Natural-language long-form prose |
| Natural-language summary | 10 | 13.51 | 56.34% | Shorter but still organized as ordinary prose |
| BabelTele | 10 | 16.70 | 80.19% | Cross-lingual fragments and symbols dominate |
Perplexity supplies another view of surface typicality. Base language models assign much lower probability to BabelTele than to either the original or the summary. For Llama-3-8B, perplexity rises from 9.63 on the original and 11.32 on the summary to 176.60 on BabelTele. Qwen3-8B moves from 14.94 to 301.22, and DeepSeek V4 Pro from 7.67 to 108.95. Every diagnostic model shows an order-of-magnitude increase, so the effect is not specific to one tokenizer or one base model.
| Base model | Original PPL | Summary PPL | BabelTele PPL | Change from original |
|---|---|---|---|---|
| Llama-3-8B | 9.63 | 11.32 | 176.60 | +1733.9% |
| Qwen2-7B | 10.93 | 12.44 | 236.23 | +2061.1% |
| Qwen2.5-7B | 10.43 | 11.56 | 209.30 | +1906.7% |
| Qwen3-8B | 14.94 | 15.22 | 301.22 | +1916.2% |
| Qwen3-32B | 11.80 | 11.07 | 220.76 | +1770.8% |
| Kimi K2P6 | 6.93 | 7.76 | 127.96 | +1746.5% |
| DeepSeek V4 Pro | 7.67 | 7.75 | 108.95 | +1320.5% |
| GLM 5.1 | 7.89 | 8.40 | 148.23 | +1778.7% |
If these two diagnostics were the whole study, the reasonable conclusion would be that BabelTele is malformed text. The authors' key observation is that downstream behavior does not collapse in the same way. Human participants become less accurate and report greater difficulty, but Gemini 3.1 Pro does not show a comparable human-like failure on the same representations. The experiment therefore separates at least three quantities: human readability, probability under a natural-language model, and an instruction model's ability to recover task-relevant semantics.
The strongest justified conclusion is limited: on this small QuALITY study, those quantities can diverge. The result does not prove that the model understands the source in a human-like way. The paper consistently uses downstream recoverability rather than making a claim about conscious understanding. It demonstrates a behavioral separation on selected questions, while leaving the internal explanation and broader task coverage open.
5. The accuracy-retention frontier
The main evaluation covers 2,128 QuALITY questions and 2,586 MeetingBank questions across 116 runs. BabelTele and natural-language summaries are evaluated with the same producer and reader models, while LLMLingua-2 serves as an extractive compression baseline. Generative compression methods cannot be forced to hit exactly the same retention ratio, so the paper compares accuracy-retention frontiers: for a given amount of retained context, which method preserves more answer accuracy?
As compression becomes more aggressive, summaries and LLMLingua-2 tend to lose accuracy faster than BabelTele. BabelTele forms a more favorable frontier across several reader models. The MeetingBank result is particularly strong, where Gemini 3.1 Pro and Qwen3.5-Plus remain close to the uncompressed result after substantial token reduction. QuALITY shows a smaller advantage, but the direction is still consistent across multiple settings.
Figure 3: Cross-model accuracy on LongBench v2-Short. Rows are readers, columns are compressors, and Baseline denotes uncompressed input.
The paper evaluates a family of BabelTele-style prompts instead of selecting one unusually successful instruction. The variants differ in their mixture of languages, structural markers, logical symbols, and relation compression. Their collective behavior produces the reported frontier. Treating BabelTele as a representation family rather than a single magic prompt reduces the chance that the outcome is only an artifact of one wording, although it does not eliminate the coupling between prompt design and pretraining distribution.
Compression can also move computation from the input context to the answer. The authors measure the reader's chain-of-thought token count relative to the uncompressed baseline. As retention falls, reasoning tokens often increase. One interpretation is that a sparser representation leaves the reader to locate, reconstruct, or disambiguate relations that were explicit in the source. A token saved in the prompt may therefore create additional output tokens or latency.
BabelTele does not show uniquely high reasoning overhead in these measurements. Its multiplier is generally comparable to or lower than the summary and LLMLingua-2 baselines, and under light compression it can be below the original-context baseline. These counts are auxiliary runtime evidence, not a measure of understanding and not a safety guarantee. The practical implication is that moderate compression may offer a better total-cost tradeoff than the most aggressive setting, even when aggressive compression looks attractive on input length alone.
Figure 5: Reader chain-of-thought token multipliers on LongBench v2-Short relative to uncompressed input.
6. Cross-model compatibility is real but conditional
The transfer study uses 180 LongBench v2-Short samples and 214 QuALITY instances. Each compressor produces a representation that multiple readers consume, separating the question of which model can compress from the question of which model can read. The paper reports homogeneous settings, where one model both produces and consumes, and heterogeneous settings, where producer and reader differ.
Compression aggressiveness varies sharply by producer. Gemini 3.1 Pro often removes more than 95% of the source tokens, GPT-5.4 is near 75%, and several other models fall between roughly 80% and 90%. A smaller output is not automatically a better representation. More aggressive compression can force more information into implicit relations and make the reader reconstruct evidence that a less compact representation would have exposed directly.
The accuracy matrices show usable heterogeneous transfer on both LongBench v2 and QuALITY, but the results depend on the producer-reader pair. On QuALITY, representations produced by GPT-5.4 and Claude are broadly usable by several readers, while representations from Qwen and Kimi cause larger losses for some combinations. This supports partial shared structure across model families, not a universal encryption scheme.
Figure 4: Cross-model accuracy on QuALITY. The same compressor can be substantially more portable to some readers than to others.
Model size is not a reliable predictor by itself. The paper fixes Gemini 3.1 Pro as the compressor and compares Qwen readers at 14B, 27B, 35B-A3B, 397B-A17B, and Qwen3.6-Max-Preview. Accuracy drops by 10.75 to 14.95 percentage points, without a monotonic improvement as parameter count increases. The 397B-A17B model starts with the highest original accuracy, but after BabelTele its score is still below the 27B model.
| Reader model | Original accuracy | BabelTele accuracy | Drop | Relative retention |
|---|---|---|---|---|
| Qwen3-14B | 78.97% | 64.02% | 14.95 points | 81.07% |
| Qwen3.5-27B | 91.59% | 80.84% | 10.75 points | 88.26% |
| Qwen3.5-35B-A3B | 90.65% | 75.70% | 14.95 points | 83.51% |
| Qwen3.5-397B-A17B | 93.93% | 79.91% | 14.02 points | 85.07% |
| Qwen3.6-Max-Preview | 90.19% | 79.44% | 10.75 points | 88.08% |
For engineering, this means BabelTele behaves more like an inducible representation capability than a standardized wire format. A system that always uses the same model may obtain good results from homogeneous compression. A system that routes messages across providers must test each producer-reader pair. The zero-shot label means that no reader-specific training is required; it does not mean that deployment requires no calibration.
The transfer reasoning-token matrices point to a similar boundary. Aggressive compression often increases the reader's output work, but the paper does not interpret longer reasoning as proof of failure. A more careful explanation is that explicit source material has become implicit reconstruction work. The optimal retention ratio depends on the relative cost of input and output tokens, latency requirements, and the accuracy floor of the application.
Figure 6: Reader chain-of-thought token multipliers on QuALITY. More aggressive input compression often shifts work to the answer stage.
7. Agent messages, memory, and repository-scale context
The first downstream system is two-agent communication. Two agents exchange intermediate messages on DeepResearch Bench. In the homogeneous condition both use Gemini 3.1 Pro; in the heterogeneous condition Gemini 3.1 Pro is paired with GPT-5.4. BabelTele compresses a message before the next agent receives it, testing whether a model can both produce and consume task-relevant action information in the dense format.
The homogeneous setup reduces communication tokens by 38.96% while retaining 96.6% of the final score. The heterogeneous setup reduces tokens by 44.21% while retaining 99.7%. These are strong results for the tested workflow, but the scope remains two agents and specific DeepResearch tasks. The experiment does not establish behavior for arbitrary topology, long-running tool use, error propagation, or human audit requirements.
The second application is LoCoMo long-term conversational memory. Ten conversations are compressed session by session. A query is compared with the resulting session summaries, the four highest-scoring sessions are retrieved, and Gemini 3.1 Pro answers while GPT-4o-mini performs scoring. Compression and answering use the same model, so this experiment is primarily a memory-pipeline evaluation rather than a cross-model transfer test.
| Memory method | Average tokens per query | Accuracy | Relative original accuracy | Observation |
|---|---|---|---|---|
| Original memory | 2819.5 | 64.81% | 100.00% | Most complete context and highest cost |
| Natural-language summary | 1365.6 | 61.05% | 94.20% | Roughly halves tokens but loses conversational detail |
| BabelTele | 1382.2 | 62.53% | 96.48% | Similar cost to summaries with more retained accuracy |
On LoCoMo, BabelTele retains about half the tokens rather than the 27.9% aggregate seen in the long-document setting. The authors attribute this to short sessions averaging around 700 tokens. Aggressive compression is more likely to damage names, references, and conversational details when the source has little redundancy. The result is an important boundary: BabelTele is not governed by a rule that shorter output always produces a better tradeoff.
The third application exceeds the model context window. LongBench v2 Code Repo QA Long averages roughly 1.65 million input tokens, above the tested models' 200K to 256K windows. The truncation baseline keeps only the portion that fits. BabelTele instead splits the repository text into 200K-token chunks, compresses each chunk with Gemini 3.1 Pro, and presents the combined representations to the reader.
| Method | Qwen3.6 Max | GLM-5.1 | Kimi2.5 |
|---|---|---|---|
| Truncated original context | 55.17% | 62.07% | 44.82% |
| BabelTele over 200K-token chunks | 62.07% | 72.41% | 48.28% |
All three readers improve, with the strongest gain for GLM-5.1. The most plausible explanation is coverage: truncation can expose only a fixed window, while chunked compression lets the reader see evidence from more of the repository. This does not show that BabelTele preserves all code semantics. Cross-chunk call chains, configuration dependencies, and distant relationships between implementation and tests can still disappear, and chunk boundaries may determine which evidence remains coherent.
Together, the downstream studies support a bounded claim: dense model-oriented representations can preserve enough task information for selected message-passing, memory, and long-document workflows. They also define the failure surface. Short conversations need gentler compression, heterogeneous model pairs need calibration, and repository tasks remain dependent on chunking and cross-chunk evidence. The paper does not establish a general production protocol from these examples.
8. Code availability and reproduction boundaries
At the time of this analysis, the paper provides no verifiable official code release. The community repository lukaszgryglicki/babeltele uses the same project name but should not be labeled an official implementation. It is AGPL-3.0 and centers on deterministic Rust text filtering, with support for an optional language-model backend. That engineering path differs materially from the paper's zero-shot prompting of general models to generate multilingual symbolic representations.
An exact reproduction therefore requires rebuilding the prompt templates, model calls, token accounting, dataset splits, answer judging, and cross-model matrices. Calling the community filter's output BabelTele in the paper's sense would conflate two different representations. The accurate status is: no official implementation, a non-official community project in a related direction, no specialized trained weights, and a method whose core depends on prompting existing models.
Absence of official code does not erase the empirical observation, but it reduces reproducibility. Prompt wording, system instructions, temperature, output limits, model snapshots, and tokenizer choice can all alter both the retention ratio and the resulting surface form. The paper's use of several prompt variants is a useful robustness measure, but future work should publish the full requests, seeds where applicable, model version identifiers, and evaluation scripts.
9. Why this matters for robots and agent infrastructure
The paper's main conceptual contribution is to make readability an explicit design choice rather than an assumed prerequisite for compression. Natural-language systems often treat human-readable syntax, high language-model likelihood, and semantic fidelity as if they rise and fall together. The experiments show that these axes can separate on selected model-task combinations. For agent infrastructure, that observation invites a cleaner distinction between internal representation and external explanation.
Robot systems repeatedly pass perceptual descriptions, plans, tool outputs, memory records, and coordination messages through models. Some of those intermediate states need to remain readable to operators; others are consumed only by another model. Dense representations may reduce context cost for the internal path, while human-facing safety prompts, explanations, audit logs, and recovery instructions should remain legible. A system should explicitly identify which layer each message belongs to instead of allowing an optimization for one layer to silently spread into all of them.
Human inspection also becomes a weak fallback when the intermediate format is intentionally illegible. The design goal makes it difficult for an operator to notice a dropped negation, changed unit, reversed temporal relation, or altered permission. A serious quality gate therefore needs automated task suites, assertion checks for critical entities and constraints, cross-model regression tests, and original-source pointers. In safety-critical robotic settings, retaining the source evidence or a recoverable human-facing representation is more defensible than relying on a fluent final answer alone.
The work also suggests that model-to-model protocols may be induced dynamically rather than designed once as a fixed syntax. That flexibility is useful but creates versioning and audit problems. A production system would need to record the compressor, reader, prompt version, tokenizer, retention target, validation score, and model snapshot for each representation contract. Otherwise a model upgrade may change the effective protocol while every component continues to report success.
The safest architectural reading is not that natural language should be replaced. It is that two representations may be needed: a dense internal form optimized for model consumption and a human-governed form for objectives, explanations, evidence, and accountability. This separation captures the reported efficiency benefit without pretending that human interpretability is no longer valuable.
10. Limitations and risks
The authors explicitly note that the benchmark and model coverage is limited. BabelTele is evaluated on selected tasks and model families, not on every architecture, modality, domain, or production workload. Results on long-document QA do not guarantee that open-ended reasoning, tool use, code modification, or multimodal robot tasks retain similar semantics under aggressive compression.
The second author-stated limitation is that the paper characterizes a phenomenon without explaining its mechanism. It shows that models can generate and consume low-readability representations, but it does not identify why particular producer-reader pairs transfer better, nor does it locate the behavior in representation geometry, training data, or attention dynamics. Without a mechanism, failure diagnosis is difficult: a drop could come from missing entities, collapsed relations, ambiguous symbols, or insufficient reader reasoning.
The ethics statement adds a direct safety warning. Transformed text may change model behavior unexpectedly, and deployment in safety-critical domains could harm safety or introduce unanticipated risk. This risk is subtler than in ordinary summarization because a person cannot quickly inspect whether the compressed string preserved a negation, condition, unit, identity, or hazardous constraint. A model answering routine questions correctly does not rule out misreading an exceptional case.
An independent engineering concern is that high perplexity and low readability weaken manual quality control. If unreadable representations enter memory or inter-agent messages, the system should retain source pointers and reconstruction paths and should run explicit checks for numbers, negation, time, permissions, and action parameters. Otherwise a compressor-reader pair can drift together and propagate errors through multiple agents while the human-facing log contains only opaque internal symbols.
A second independent concern is dependency between compressor and reader. Cross-model evidence supports zero-shot transfer, but accuracy varies by pair and does not improve monotonically with model size. Treating BabelTele as a universal protocol could produce silent degradation: responses remain fluent while evidence lost during compression is no longer available. Production use requires pair-specific regression tests rather than validation of compression ratio or same-model self-reading alone.
Finally, the headline pair of 27.9% retention and 99.5% semantic fidelity should not be detached from its evaluation context. It does not mean that any document can discard 72.1% of its tokens and retain 99.5% of all information. The defensible claim is narrower: across the paper's tested model-task combinations, BabelTele provides a competitive accuracy-retention frontier. A new workload must be measured before that claim is transferred to it.
11. Conclusion
BabelTele turns human readability from a default requirement into an optional constraint. It uses multilingual word selection, symbolic collapse, and recoverable semantic density to elicit discrete model-oriented text without gradients, special tokens, tokenizer changes, or an external codebook. Readability scores and perplexity show that the result is far from ordinary English prose. Document QA, cross-model reading, multi-agent messages, long-term memory, and repository-scale chunking then show that models can recover useful task evidence from at least part of that representation.
The method is not yet a stable communication protocol. Performance depends on compressor, reader, task length, and retention ratio; cross-model transfer is asymmetric; and aggressive compression can shift work into longer reader reasoning. Its strongest contribution is an empirical signal: the surface form of natural language is not the entire set of representations available to a model. Turning that signal into reliable infrastructure requires mechanistic study, broader benchmark coverage, auditable representation versions, pair-specific regression testing, and a human-readable evidence layer for safety-critical decisions.
SOURCE LINKS



