Language on TurboVision

The Real Historical Analogy

Mon, 20 Apr 2026 00:00:00 +0000

The most popular analogies around AI are usually the worst ones, because they jump straight to apocalypse, utopia, or machine rebellion and miss the transformation already happening in front of us. A far better analogy is older, less glamorous, and much more revealing: the history of writing becoming administration.

TL;DR

The strongest historical analogy for LLMs is not Skynet, industrial automation, or a new species. It is the old pattern in which an expressive medium expands access and then hardens into records, templates, procedure, governance, and bureaucracy. Less cinema. More paperwork. Unfortunately that is usually where real power hides.

The Question

You may ask: if natural-language AI feels like a liberation from rigid interfaces, what historical pattern does it actually resemble? Is there an older moment where a flexible medium spread widely and then slowly turned into structure, procedure, and control?

The Long Answer

Yes. Writing.

The Better Analogy Is Older and Less Glamorous

Or more precisely: writing after it stopped being rare.

When we romanticize writing, we think of poetry, letters, memory, literature, philosophy, scripture, and thought made durable. All of that matters. But historically, writing did not remain only an expressive medium. As soon as it became socially central, it also became a machine for legibility.

It began to support:

ledgers
tax records
property claims
legal formulas
decrees
inventories
forms
standard contracts
administrative routines

The same medium that enabled reflection also enabled bureaucracy.

That is not an accidental corruption of writing’s pure spirit. It is what happens when an expressive medium starts carrying coordination at scale. The lyric and the ledger share a medium, and the ledger is usually better funded.

This is the historical rhyme that matters for AI.

Natural-language interfaces feel, at first, like a return from bureaucracy to speech. No more memorizing commands. No more obeying narrow syntactic rituals. No more learning the machine’s rigid grammar before the machine will meet you halfway. You can just speak.

But the moment that speech starts doing real work, the old dynamic reappears. The free exchange has to become legible, stable, and reusable. Then come templates. Then conventions. Then control layers. Then record-keeping. Then policy.

In other words, the medium begins to administrate.

Writing Became Administration

That is why I think the right analogy is not “AI replaces humans” but “language-to-machine interaction is becoming administratively scalable.” That phrase has none of the drama of science fiction, which is exactly why I trust it.

Notice how much current AI practice already fits that pattern.

At the expressive edge:

exploratory prompting
brainstorming
rewriting
questioning
improvisation

At the administrative edge:

system prompts
reusable role definitions
skill files
output schemas
tool policies
safety rules
evaluation harnesses
memory and trace retention

That is exactly the same medium bifurcating into two functions:

expression
governance

The mistake would be to think governance arrives from outside as an alien force. More often it emerges from the medium’s own success. Once too many people, too many workflows, and too many risks pass through the channel, informal use becomes too expensive.

This is why the writing analogy beats the science-fiction analogy. Science fiction lets us talk about AI while keeping one eye on spectacle. Administration forces us to talk about rules, defaults, records, compliance, and who gets to decide what counts as proper use. Less fun, more dangerous.

Science fiction keeps us staring at agency in the dramatic sense: rebellion, consciousness, domination, replacement. Those questions may have their place, but they are not what we are living through most directly right now.

What we are living through is far more mundane and therefore far more transformative:

who gets to issue instructions
in what form
with what defaults
under whose hidden constraints
with what record of compliance
and according to which evolving norms

That is administration.

A government clerk, a shipping office, a medieval chancery, and a modern AI platform may look worlds apart, but they share one deep concern: turning messy human intentions into legible operations.

That is why some of the current discourse feels so unserious to me. People keep asking whether the machine is becoming a person while entire companies are busy making it into procedure.

Once you look through that lens, many supposedly strange features of the current AI moment become obvious.

Why are people standardizing prompts? Because legibility enables coordination.

Why are teams writing internal style guides for model use? Because institutions cannot run on charm alone.

Why do skill files, tool schemas, and structured outputs proliferate? Because the medium is being prepared for scale.

Why does the language of “best practice” appear so quickly? Because informal success always creates pressure for repeatability.

Freedom and Bureaucracy Grow Together

This is also why the present moment feels ideologically confused. We are using the rhetoric of liberation while simultaneously building new bureaucratic layers. People notice the contradiction and either celebrate one side or denounce the other. I think both reactions are too simple.

The bureaucracy is not a betrayal of the freedom. It is what the freedom becomes when it has to survive contact with institutions.

That is an irritating sentence, but I think it is true.

There is another historical layer worth noticing: standardization often follows democratization, not the other way around.

Printing expands who can read and write, and then spelling, grammar, and editorial norms harden. Open networks expand who can communicate, and then protocols stabilize the traffic. Mass politics expands participation, and then bureaucracy grows to make populations administratively legible. Natural-language computing expands who can “program,” and then prompt rules, tool contracts, and agent frameworks appear.

This pattern is almost embarrassingly regular. We keep acting surprised by it anyway, which may be one of the more stable features of modernity.

It should also change how we talk about power.

The frightening question is not only whether AI becomes an autonomous sovereign. The more immediate question is who controls the administrative grammar of human-machine exchange. In older regimes, literacy itself was power. Later, access to legal language was power. Later still, access to code and infrastructure was power.

Now the emerging power may sit in the ability to shape:

system defaults
hidden instructions
moderation layers
tool affordances
evaluation criteria
acceptable interaction styles

That is a quieter kind of power than Skynet fantasies, but in practice it may matter more. It is much easier to smuggle power in through defaults than through manifestos.

Because most people will not meet AI as pure model weights. They will meet it as institutionalized behavior.

And institutionalized behavior is always partly political.

The Real Struggle Is Over Administrative Power

This is where the analogy becomes genuinely useful rather than merely clever. It gives you a way to organize the whole field without falling into either marketing or panic.

You can ask of any AI feature:

Is this expressive? Is this administrative? Or is it a hybrid trying to hide the transition?

A freeform chat UI is expressive. A schema-constrained workflow is administrative. A friendly assistant with hidden system rules is a hybrid, and hybrids are where most of the real tension lives.

The writing analogy also helps explain the emotional tone people bring to AI. Some are exhilarated because they feel the expressive release. Others are suspicious because they can already smell the coming bureaucracy. Both are perceiving real parts of the same transformation.

The optimists are seeing the collapse of unnecessary formal barriers. The skeptics are seeing the rise of a new governance layer.

Again, both are right.

And this returns us to the opening paradox. Why does a medium that promises freedom generate rules so quickly? Because freedom by itself is not enough for archives, institutions, teams, compliance, safety, memory, and distributed execution. A society can play in a medium informally for a while. It cannot run on that informality forever.

That does not mean we should embrace every new layer of prompt bureaucracy with cheerful obedience. Quite the opposite. Once you recognize the administrative turn, you can ask better questions:

which rules are genuinely useful?
which are cargo cult?
which increase transparency?
which hide power?
which preserve human agency?
which quietly narrow it?

That is the adult conversation.

So if you want the real historical analogy, here is mine:

LLMs are not best understood as a talking machine waiting to rebel. They are better understood as the latest medium through which human intention becomes administratively legible at scale.

That may sound less cinematic than Skynet, but it is more historically grounded and much more relevant to the systems we are actually building.

The true drama is not that the machine may wake up one day and declare war. The true drama is that we may succeed in building a new universal administrative layer and barely notice how much social power gets embedded in its defaults, templates, and permitted forms of speech.

An ugly example helps here. Suppose every internal assistant in a large company quietly prefers one style of project plan, one tone of escalation, one definition of risk, one preferred sequence of approvals, one acceptable way of disagreeing. Nobody declares a doctrine. Nobody publishes a manifesto. People just start adapting to what the system rewards. That is how a lot of administrative power actually enters the room.

That is not a reason for panic. It is a reason for seriousness.

Every civilization that learns a new medium first celebrates its expressive power. Soon after, it learns what paperwork can do with it.

Summary

The best historical analogy for LLMs is not cinematic rebellion but administrative expansion. Like writing before them, natural-language interfaces begin as expressive tools and then harden into templates, records, procedures, and governance. That is why AI feels simultaneously liberating and bureaucratic: both experiences are true, because the same medium is serving both expression and institutional control.

Seen this way, the important question is not whether structure will emerge. It is whether the coming administrative layer will stay legible, contestable, and open to public scrutiny, or whether it will arrive in the usual smiling way: convenient, useful, efficient, and already half invisible.

When AI becomes part of society’s paperwork rather than its science fiction, who will notice first that the defaults have become law-like?

Is There a Hidden Language Beneath English?

Thu, 16 Apr 2026 00:00:00 +0000

Most prompt engineering is written in English, and the industry often treats that fact as if it were almost self-evident. But once you ask whether English is truly the best control medium or merely the most overrepresented one, the ground starts moving under the whole discussion.

TL;DR

There is no strong evidence yet for one universal hidden “control language” beneath English. But there is real evidence that useful control can happen through non-natural-language mechanisms such as soft prompts, steering vectors, and latent or activation-based agent communication. So the idea is not crazy. It is just easier to say crazy things around it than careful ones.

The Question

You may ask: if models live in a high-dimensional latent space, why are we still steering them with ordinary English sentences? Could there be a shorter, more efficient machine-native control language hidden under natural language, especially for agent-to-agent communication?

The Long Answer

This is one of the most interesting questions in the whole field, partly because it contains a real idea and partly because it attracts nonsense like a magnet.

Why the Idea Is Plausible

So let us separate what is plausible, what is established, and what is still an extrapolation, because this is exactly the kind of topic where people start sounding profound five minutes before they start lying to themselves.

The plausible part comes first: natural language is almost certainly a lossy bottleneck.

A model does not “think” in final output tokens alone. Internally it moves through activations, intermediate representations, attention patterns, and hidden states that contain far more structure than the sentence it eventually emits. The emitted sentence is not the whole state. It is the public projection of that state into a human-readable channel.

Once you see that, your idea becomes immediately legible in technical terms. You are asking whether the human-readable wrapper is an inefficient control surface over a richer internal space, and whether two models might communicate more efficiently by exchanging compressed internal representations instead of serializing everything into English.

That is not fantasy. It is already brushing against several real research directions.

There is older work on emergent communication in multi-agent systems where agents invent message protocols that are useful to them but opaque to us. The 2017 paper Translating Neuralese is one of the early landmarks here. It did not show that agents had discovered some mystical perfect language hidden behind reality like a sacred cipher. It showed something more useful: agents can develop internal communication forms that are meaningful in use even when they are not naturally interpretable by humans.

More recent work pushes this further toward language models specifically. Papers such as Communicating Activations Between Language Model Agents and Interlat: Enabling Agents to Communicate Entirely in Latent Space explore the idea that agents can exchange internal activations or hidden-state-like representations directly, rather than always crushing them down into text first. The reported benefit in that line of work is exactly what you would expect: less information loss and often lower compute cost than long natural-language exchanges.

So the broad direction of the intuition is already technically alive. That matters.

Where the Evidence Actually Exists

Now for the annoying but necessary part.

What we do not have, at least not in any established sense, is proof of one clean latent language sitting beneath English that we can simply reveal by subtracting the “English component.” I do not know of research that validates that exact decomposition in the neat form described. And this is exactly where people are tempted to jump from “the latent space is real” to “there must be a hidden universal language in there somewhere.” Maybe. But maybe is doing a lot of work there.

Why not? Because the internal geometry is probably not that simple.

English inside a model is not just “semantic content plus a detachable language shell.” It is entangled with tokenization, training distribution, stylistic priors, instruction-following habits, benchmark pressure, and all the historical accidents of the corpus. Meaning, format, tone, and control are mixed together.

So I would challenge one very seductive picture: there is probably no single secret Esperanto of the latent space waiting patiently behind English, ready to reward whoever is clever enough to discover it.

What is more likely is messier and, in my opinion, more interesting:

many partially reusable internal control directions
many task-specific compressed protocols
many model-specific or architecture-specific latent conventions
some transferable abstractions, but not one canonical hidden language

This is where soft prompts, prefix tuning, and steering vectors become useful to think with.

Why a Single Hidden Language Is Unlikely

Soft prompts are not ordinary words. They are learned continuous vectors injected into the model’s input space. Prefix tuning generalizes that idea deeper into the network. Steering vectors act differently but share the same spirit: instead of asking with words alone, you manipulate the model by shifting internal activations in directions associated with some behavior or concept.

That is already a kind of non-natural-language control, and it should make people at least a little suspicious of the lazy assumption that human language is the final or natural control layer forever.

Notice what that implies. We already have control methods that are:

effective
compact
not human-readable
native to representation space rather than sentence space

English is therefore not the only control medium. It is simply the most interoperable one for humans.

And that point matters, because it reveals the real trade-off.

Human language is inefficient, but legible. Latent control is efficient, but opaque.

That single sentence is the heart of the matter, and also the trade-off a lot of AI discussion would rather not stare at for too long.

If two agents share architecture, alignment, and task context, there is every reason to suspect they could communicate more efficiently than by exchanging verbose English paragraphs. They could use compressed summaries, vector codes, reused cache structures, activations, or learned latent shorthands. Once the agents no longer need to satisfy human readability at every intermediate step, natural language begins to look less like the native medium and more like a compatibility layer.

That does not mean English is useless or even secondary. It means English may belong mostly at the boundary:

human to agent
agent to human

while agent to agent may migrate toward denser internal forms.

The Agent-to-Agent Case Is the Real Frontier

This layered picture fits both engineering and history. Systems tend to expose legible interfaces at the top and efficient, ugly protocols underneath. TCP packets are not prose. Database wire formats are not essays. CPU micro-ops are not source code. So why should advanced agent swarms eternally chatter to each other in polite human language unless a human auditor needs to read every step?

There is also a small absurdity here that is hard not to enjoy. We may be heading toward systems where two expensive reasoning agents exchange page after page of immaculate English purely so that humans can feel the process remains respectable, while both machines would probably prefer to swap a denser internal shorthand and get on with it.

There is another issue in our question: why English?

The honest answer is likely mundane rather than metaphysical, which is unfortunate for anyone hoping for a more glamorous answer.

English is privileged today because:

much of the training data is English-heavy
much of the instruction-tuning corpus is English-heavy
many benchmarks are English-centric
most prompt-engineering lore is shared in English
tool docs, code, and interface conventions are often English-first

So the dominance of English may say less about some deep optimality of English and more about the industrial history of model training. Sometimes the explanation is not “English maps best to reason.” Sometimes the explanation is simply “the pipeline grew up there.”

That said, replacing English with another human language is not yet the same as discovering a latent control protocol. Those are different questions.

One asks: which human language is better for steering? The other asks: must steering remain in human language at all?

The second question is the deeper one.

Human Legibility Versus Machine Efficiency

And here I think the strongest move is not the image of “subtract English and add it back later” as a literal algorithm, but as a conceptual provocation. It suggests that language may be acting as both carrier and drag. Carrier, because it gives us a shared interface. Drag, because it forces rich internal state through a narrow symbolic bottleneck.

That is exactly why agent-to-agent communication is the most credible frontier for this idea.

A human still needs explanation, auditability, and trust. Two agents collaborating under a shared protocol may care far less about elegance and far more about compression, precision, and bandwidth. They may converge on communication that looks to us like gibberish, or even bypass discrete language entirely.

If that happens, the implications are substantial.

First, debugging gets harder. You can inspect English. You can argue about English. You can regulate English. Hidden-state exchange is much less socially governable. It is also much easier to wave away with phrases like “trust the model” when nobody can really see what is happening.

Second, interoperability becomes a real problem. A latent protocol learned by one model family may fail catastrophically with another. Natural language is slow, but it is remarkably portable.

Third, alignment may get stranger. A human can often spot trouble in verbose reasoning traces, at least sometimes. A compressed latent exchange could be more capable and less inspectable at the same time.

So I would state the thesis like this:

There may not be one hidden language beneath English, but there are probably many machine-native control regimes that natural language currently obscures.

That is the version I trust.

It leaves room for real progress without pretending the geometry is cleaner than it is. It respects the evidence from soft prompts, steering, and latent-agent communication without claiming that the grand unified control language has already been found. And it points toward the place where the idea matters most: not in helping humans write ever more magical prompts, but in letting agents exchange context faster than prose allows.

That future, if it comes, will not feel like the discovery of a secret language carved into the bedrock of intelligence. It will feel more like the emergence of protocol families: efficient, narrow, powerful, local, and only partially intelligible from the outside.

Which is, frankly, how real technical history usually looks. Messier than prophecy, less elegant than theory, and much more interesting.

Summary

There is no solid reason yet to believe in one universal hidden control language beneath English. But there is good reason to suspect that natural language is only one control surface among several, and not necessarily the most efficient one for every setting. Soft prompts, steering vectors, and latent or activation-based communication all point in the same direction: human language may remain the public interface while more compressed machine-native protocols emerge underneath.

The most promising use case for that shift is not magical human prompting. It is agent-to-agent coordination, where efficiency may matter more than legibility. The seduction of the idea lies in human prompting. The real engineering value may lie somewhere else entirely.

If the most capable future agent systems stop explaining themselves to each other in human language, how much opacity are we actually willing to accept in exchange for speed and capability?