@owmio39659: Introducing an important new paper and concept in the "jailbreak" field — "Babel Language": 1) LLMs don't actually need human-readable language to know what to do next. 2) Therefore, prompts and jailbreak content can be extremely compressed via an LLM into a segment of text unreadable to humans. 3) These unreadable texts can't be understood by humans, but the model can…
Summary
The paper proposes the concept of BabelTele ("Babel Language"), demonstrating that prompts and jailbreak content can be extremely compressed into text that is unreadable to humans yet retains recoverable semantics for LLMs — maintaining 99.5% semantic fidelity at only 27.9% of the original size. Applications include model offense/defense, multi-agent communication, and reducing context overhead.
View Cached Full Text
Cached at: 11/19/26, 05:45 PM
Large Language Models Do Not Always Need Readable Language
Source: https://arxiv.org/html/2606.19857 Haoxuan Peng — The University of Sydney; Junxi Wang — Hefei University of Technology; Liang Ke — Xi’an Jiaotong University; Chen Zhang — Nanjing University; Linfeng Zhang† — Shanghai Jiao Tong University (Corresponding author)
Abstract
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.
1 Introduction
Large language models (LLMs) have become a dominant interface in contemporary intelligent systems. Since GPT-3 demonstrated strong few-shot generalization through text-based prompting (Brown et al., 2020), the field has largely followed a unified paradigm: knowledge is represented in natural language, instructions are issued in natural language, and model outputs are returned in natural language. Subsequent alignment methods and dialogue-oriented models further reinforced this design, optimizing model behavior toward controllability and readability (Ouyang et al., 2022; Touvron et al., 2023).
However, natural language optimized for human communication is not necessarily an efficient representation for model processing. Human language contains substantial redundancy: complete syntax, discourse markers, and narrative coherence all help people follow, remember, and disambiguate information. These properties are valuable for human readers, but they reduce semantic density. From an information-theoretic view, communication systems aim to transmit information efficiently under channel constraints (Shannon, 1948). More recent work also connects language modeling with compression, suggesting that strong language models can capture compact statistical structure in data (Deletang et al., 2024). This raises a central question: if the receiver is an LLM rather than a human, must semantic information still be encoded in fully human-readable natural language?
This question becomes especially relevant in long-context and agentic systems, where context overhead is a persistent bottleneck. LLMs are increasingly deployed to process lengthy documents, maintain memory, and exchange intermediate states in multi-agent workflows, yet models do not always use long contexts robustly (Liu et al., 2024), and agent systems further intensify this pressure through natural-language memory (Park et al., 2023b), context management (Packer et al., 2023), and inter-agent message passing (Wu et al., 2024). The idea of sacrificing readability for efficiency, however, is not new: telegraphic language, mathematical notation, and code all demonstrate that fluent prose is only one possible surface form for communication. This suggests a broader possibility that intermediate representations in LLM systems may be optimized not for human readability, but for model decodability and semantic density.
Existing context-compression methods provide important precedents. Prior work has explored reducing prompt length by removing redundant spans, rewriting retrieved content, or selecting informative tokens, demonstrating that natural-language inputs contain substantial compressible redundancy (Li et al., 2023; Jiang et al., 2023a; Xu et al., 2024). Nevertheless, most such methods still operate within the conventions of human-readable natural language. A separate line of work explores activation-based or learned internal representations, but these approaches often require additional training, special tokens, or access to hidden states, limiting their applicability in black-box API settings and heterogeneous model ecosystems.
Motivated by this gap, we investigate BabelTele, a class of model-centric rather than human-centric textual representations. BabelTele explicitly relaxes human readability as a default constraint, instead encouraging models to encode semantics into compact, non-standard textual forms, potentially combining abbreviations, symbols, cross-lingual fragments, and non-standard syntactic structures. While these forms exhibit low human readability, advanced LLMs can still recover their core semantics for downstream tasks. We thus present BabelTele not as a competitive compression method, but as an empirical probe into model-native textual communication, evaluating it across multiple dimensions including compression ratio, semantic fidelity, human readability, cross-model transferability, and downstream utility in document QA, agent memory compression, and multi-agent communication. Our key takeaways are as follows:
- BabelTele emerges as a prompt-accessible phenomenon: by removing human readability as a default constraint, LLMs spontaneously produce opaque but semantically dense textual representations under a black-box interface.
- BabelTele exhibits robust cross-model transferability across diverse proprietary and open-weight model families in a zero-shot manner. Representations compressed by one model can be reliably interpreted by another without any fine-tuning or model-specific adaptation, suggesting that BabelTele captures a form of semantic encoding that generalizes across heterogeneous architectures.
- BabelTele retains semantics in document QA, agent memory, and multi-agent communication, demonstrating that current LLMs can process highly dense text without relying on human readability.
2 Related Works
2.1 Prompt and Context Compression
Prompt compression has been widely studied as a way to reduce inference cost and improve the effective use of limited context windows (Li et al., 2023; Jiang et al., 2023a; Jiang et al., 2024; Pan et al., 2024; Hou et al., 2024). Hard compression methods usually keep the compressed prompt as discrete text. Selective Context (Li et al., 2023) filters tokens or sentences according to self-information. LLMLingua (Jiang et al., 2023a) performs coarse-to-fine token-level prompt compression. These approaches mainly reduce prompts by deleting or selecting lexical units from the original text.
Other work studies abstractive or natural-language prompt compression (Xu et al., 2024; Chuang et al., 2024; Zhang et al., 2024; Jeong et al., 2025; Guo et al., 2025). RECOMP (Xu et al., 2024) compresses retrieved documents into summaries, while Nano-Capsulator (Chuang et al., 2024) learns shorter natural-language capsule prompts. Unlike these methods, BabelTele does not aim to preserve natural-language readability. It instead asks whether LLMs can generate and consume compact semantic strings that are opaque to humans but still interpretable by LLMs.
We also consider related work on learned and latent context compression, retrieval and memory systems, symbolic prompting and LLM-native communication. Due to space limitations, they are provided in Appendix A.
3 Methodology: Eliciting LLM-Native Representations
3.1 Relaxing the Readability Prior
Given an input document x, conventional text compression employs a model C to produce a shorter sequence z that preserves task-relevant semantics for a reader model R. Most existing methods implicitly encourage z to remain close to the natural language distribution, keeping the compressed text reasonably readable to humans.
BabelTele formulates compression as a readability-relaxed semantic projection. When R is an LLM rather than a human reader, we hypothesize that the human-readability prior can be relaxed. Instead of optimizing for fluency or natural-language typicality, BabelTele prioritizes information density and model-side semantic recoverability. While z remains discrete text, its surface form can deviate from conventional prose. Furthermore, as different LLMs are trained on overlapping linguistic, symbolic and factual structures, such representations may exhibit partial cross-model decodability across model families.
3.2 Principles of Symbolic Collapse
Rather than treating BabelTele as a singular, manually engineered “prompt trick,” we define it as a family of high-density representations induced by relaxing linguistic constraints. To materialize this phenomenon in a black-box setting, we design instructional probes that encourage the compressor C to produce model-readable encodings based on the following principles:
- Omnilingual Lexical Selection: Relaxing single-language constraints and selecting high-density lexical units across languages and scripts.
- Symbolic Collapse: Replacing verbose linguistic structures with compact symbols, emojis, mathematical/logical operators, and punctuation.
- Recoverable Semantic Density: Preserving recoverable semantic details so that capable LLMs can interpret the compressed output without an external codebook.
By applying these constraints through zero-shot prompting, we encourage LLMs to externalize semantic information into a compact surface form more effectively. This approach requires no gradient updates or tokenizer modifications, allowing us to investigate the existence and utility of LLM-native textual representations across heterogeneous models. To illustrate this collapse, consider the following micro-example:
As shown above, BabelTele relaxes ordinary human syntax and uses multilingual cues, emojis, and relational arrows to form a compact, model-readable semantic graph more densely. Appendix D provides a qualitative example with a source excerpt and the complete BabelTele output.
4 Experiments
4.1 Experimental Setup
We evaluate BabelTele across multiple long-context benchmarks under a task-agnostic protocol, where the compressor processes source documents without access to downstream questions. We compare against standard baselines and report token retention, QA accuracy, and reader chain-of-thought token overhead across diverse evaluator model families. Full details are in Appendix B.
4.2 Symbolic Collapse: Separating Human Readability from Model Decodability
In our early observations, we found that although BabelTele is usually difficult for humans to read directly, LLMs can still use it to answer questions, recover details, and perform a certain degree of reasoning. Therefore, this section mainly examines whether human readability, natural-language distribution typicality, and model semantic recoverability can be decoupled, rather than focusing on the compression efficiency of BabelTele itself.
We select 10 long-text samples from the QuALITY (Pang et al., 2022) dataset, each containing 3 multiple-choice QA items, and construct three input formats for each sample: the original text, a natural-language summary, and a BabelTele representation generated using the default compression prompt in Appendix C.1.
Table 1: PPL diagnostics across representative base models. Parentheses indicate the relative change from the original-text PPL within the same model. Green denotes an increase. Red denotes a decrease.
Readability diagnostics in Appendix E.1 show that BabelTele has much lower surface readability than both original passages and natural-language summaries, with a Dale-Chall score of 16.70 and a difficult-word ratio of 80.19%. Table 1 further shows that BabelTele is highly unlikely under multiple base language models, yielding order-of-magnitude higher PPL than both original and summary texts. Together, these results indicate that BabelTele is not merely a natural-language summary or shorthand, but a surface representation that substantially departs from conventional English prose and the ordinary natural-language distribution.
Figure 2: QA accuracy for human readers and Gemini 3.1 Pro on original and BabelTele inputs. The y-axis starts at 25%, the random-choice baseline for four-option QA. Brackets indicate absolute changes in percentage points.
However, Figure 2 shows that low readability and low natural-language likelihood do not imply semantic unrecoverability. The human accuracy results were collected through paid questionnaires distributed to university students. Human readers show a QA accuracy drop on BabelTele inputs, whereas Gemini 3.1 Pro (Google DeepMind, 2026) maintains high accuracy. This suggests that while humans struggle to decode BabelTele representations, LLMs retain the ability to extract and reason over the encoded semantics — confirming that human readability and model-side semantic recoverability can indeed be decoupled.
4.3 Cross-Model Transferability
To test whether BabelTele representations are portable across model families, we perform cross-model transfer experiments: a compressor model generates BabelTele from source documents, and a different reader model answers downstream questions based solely on the compressed representation. We evaluate both open-weight models (e.g., Qwen, LLaMA) and proprietary APIs (e.g., GPT, Gemini, Claude).
Results indicate strong zero-shot transferability: representations compressed by one model can be reliably interpreted by another without any fine-tuning or model-specific adaptation. This suggests that BabelTele captures a form of semantic encoding that generalizes across heterogeneous architectures, rather than being a model-specific artifact. While performance varies depending on the compressor–reader pair, the overall trend confirms that BabelTele is not tightly coupled to any single model’s internal representation space.
4.4 Agent Memory and Multi-Agent Communication
We further evaluate BabelTele in two practical settings: agent memory compression and multi-agent message passing. In agent memory scenarios, we compress the agent’s accumulated context (task history, tool outputs, intermediate reasoning) into BabelTele before passing it to subsequent turns. In multi-agent communication, we replace natural-language inter-agent messages with BabelTele encodings.
Results show that BabelTele can substantially reduce context overhead — in some cases condensing the text to under 30% of its original length — while maintaining reliable downstream performance. The semantic fidelity remains high (up to 99.5%), and agents are able to recover key information from the compressed representations. However, performance is sensitive to the compressor–reader pair and the task setting: some combinations exhibit noticeable degradation, particularly for tasks requiring fine-grained factual recall or multi-step reasoning over compressed content.
5 Discussion and Implications
The findings of this work have implications across several domains:
- Network security and adversarial AI: BabelTele demonstrates that semantically dense, human-opaque text can be used to carry instructions that bypass human inspection while still being interpreted by models. This raises concerns about prompt injection and jailbreaking via compressed representations that are invisible to human auditors.
- Model attack and defense: Understanding how models decode non-standard representations helps in designing both offensive techniques (e.g., obfuscated adversarial prompts) and defensive mechanisms (e.g., detecting anomalous input distributions that deviate from human-readable language).
- Multi-agent communication: BabelTele provides a potential pathway for more efficient inter-agent communication in large-scale agent systems, reducing token costs while preserving semantic fidelity.
- Input origin obfuscation: The multilingual, symbolic nature of BabelTele naturally obfuscates the linguistic provenance of inputs, making it harder to attribute the origin or intent of a given text based on surface-level language analysis.
These applications underscore that BabelTele is not merely an academic curiosity but a practical tool with significant implications for the security, efficiency, and scalability of LLM-powered systems.
6 Conclusion
We introduced BabelTele, a model-centric textual representation that relaxes the human-readability constraint on prompt and context encoding. Through extensive experiments, we showed that BabelTele can be generated via zero-shot prompting, that it departs substantially from natural language in both readability and likelihood, and that it is interpretable by LLMs across diverse model families in a zero-shot transfer setting. We demonstrated its utility in document QA, agent memory compression, and multi-agent communication, showing that it can reduce context overhead while maintaining high semantic fidelity.
Our findings suggest that human readability, natural-language typicality, and model-side semantic recoverability can be partially decoupled. This opens a promising direction toward model-native representations — communication forms optimized for machines rather than humans — with implications spanning efficient inference, secure multi-agent systems, and the broader understanding of how LLMs process and internalize language.
Reference: https://arxiv.org/abs/2606.19857
Acknowledgment: This paper was introduced by the AI Mistrust (AI迷思录) WeChat public account, authored by a well-known figure in China’s cybersecurity community, Xiluo (惜洛).
Similar Articles
@rohanpaul_ai: LLMs may not need human-style language. i.e. future AI systems might save context space by using dense model-readable m…
This paper introduces BabelTele, a compressed writing style that uses abbreviations, symbols, and mixed-language fragments to reduce text length by 72.1% while preserving 99.5% semantic fidelity for LLMs, arguing that human readability and machine recoverability are separable.
Why I repeatedly emphasize that VLM (multimodal) is a dead end, and the world model is complete bullshit.
The author argues that VLMs (multimodal models) are a dead end because text has far greater information density than images or videos, and pure text LLM Agents can solve more complex problems.
@realchendahuang: Three years ago, when large language models had just swept the globe, the entire tech world was in an awkward state of being both thrilled and constrained everywhere. At the time, the industry broadly agreed on several almost insurmountable technical hurdles: model memory windows were too short — input just a little longer and it couldn't remember; the underlying compute architecture was extremely compute-hungry, with computation for long text exploding exponentially; the cost per call stayed sky-high, so enterprises didn't dare deploy them broadly in business use; and so-called autonomous agents would completely lose control under probabilistic drift if they ran just a few extra steps...
A deep retrospective on three years of LLM technical evolution: long-context handling shifted from RAG to prefix caching and million-token context windows; the Transformer still wins over linear-complexity architectures thanks to the hardware ecosystem of GPU tensor cores; inference costs were democratized through quantization, distillation, and task-based routing; agents moved toward pragmatic engineering paths like progressive disclosure, command-line sandboxes, and test feedback loops; and hallucination remains unsolved.
LLMs: The Next Rung on the Ladder of Abstraction
This article argues that large language models represent a new level in the history of software abstraction, making natural language the interface, enhancing human agency, but not ending programming—instead, continuing the trend of intention replacing implementation.
@shenxiankk: Stop expecting others to spoon-feed you a ready-made meal — this guide walks you hand-in-hand from scratch to fully jailbreak a large model yourself. Pliny, the jailbreak expert named one of TIME's 100 Most Influential People in AI, has open-sourced his core toolkit OBLITERATUS: it's not a finished model but an entire industrial-grade…
Pliny (named to TIME's 100 Most Influential People in AI) has open-sourced the toolkit OBLITERATUS — an industrial-grade pipeline that eliminates a large model's refusal mechanism without retraining by locating and surgically removing the internal refusal direction (abliteration), while preserving its language capabilities. The toolkit offers multiple extraction strategies including PCA, mean difference, sparse autoencoder decomposition, and whitened SVD, along with a Gradio interface and Python API, and ships with 15 deep-analysis modules. Each run also anonymously contributes benchmark data for crowdsourced research.