Protocols on TurboVision

AI, Language, and Protocols

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

A Small Essay Series

This subsection gathers a connected series of essays about what really changes once natural language becomes an interface to computation. At first that shift looks like pure liberation: fewer rigid commands, fewer formal barriers, and a much wider audience that can suddenly “program” by speaking in ordinary language. But the moment this freedom becomes useful at scale, the old questions return in a new form: structure, protocol, control, abstraction, governance, consequence, and the strange human urge to rebuild frameworks around every promising new medium.

The series moves through several connected ideas: why freedom quickly recreates formalism one layer higher, why prompting is not quite the same thing as conversation, whether a machine-native control language may sit beneath English prompting, how agent-to-agent communication could evolve beyond human prose, why the best historical analogy for all of this may not be science fiction at all, but the older story of writing hardening into administration, and why MCP changes the question from usefulness to consequence.

These texts are meant less as isolated blog posts and more as one long argument explored from different angles. They are technical where the topic demands it, philosophical where the topic deserves it, and intentionally provocative where the current AI discourse has become too shallow, too euphoric, or too lazy in its metaphors.

MCPs: "Useful" Was Never the Real Threshold -- "Consequential" was.

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

For a while, the industry kept talking as if tool access merely made models more “useful”. That description is too soft by half, because the real shift is harsher: once a model can perceive and act through an environment, its outputs stop being merely interesting and start becoming “consequential”.

TL;DR

Model Context Protocol (MCP) does not just make language models more capable in some vague product sense. It moves them closer to “consequence” by connecting model output to trusted systems, permissions, tools, and environments where words can become actions.

The Question

You may ask: if MCP is just a protocol for tools and context, why treat it as such a serious threshold? Why not simply say it makes models more “useful” and leave it at that?

The Long Answer

Because "useful" is marketing language. "consequential" is the serious word.

An LLM on its own is still mostly trapped inside text. Yes, text matters. Text persuades, misleads, reassures, coordinates, manipulates, flatters, and occasionally clarifies. But absent tool access, the model remains largely confined to symbolic output that a human still has to read, interpret, and turn into action.

The moment MCP enters the picture, that changes. Not magically. Not philosophically. Operationally.

Now the model can observe through tools. It can pull in state it was not explicitly handed in the original prompt. It can request actions in systems it does not itself implement. It can inspect, decide, act, observe the effect, and act again. In other words, it stops being merely interpretive and starts becoming infrastructural.

That is the real shift. Not more eloquence. Not slightly better automation. Consequence.

Text Was Never the Final Problem

People still talk about model output as though the main issue were what the model says. That framing is becoming stale.

If a model writes a strange paragraph, that may be annoying. If the same model can trigger a shell action, drive a browser session, modify a repository, hit an API with real credentials, or traverse a filesystem through an MCP server, then the relevant question is no longer merely “what did it say?” The real question becomes: what did the environment allow those words to become?

That sounds obvious once stated plainly, but a great deal of current AI rhetoric still behaves as though the old text-only framing were enough.

It is not enough.

A model that suggests deleting a file and a model that can actually cause that deletion are not the same kind of system. A model that proposes an escalation email and a model that can send it are not the same kind of system. A model that hallucinates a bad shell command and a model whose output gets routed into execution are not separated by a minor implementation detail. They are separated by consequence.

That is why I do not like the soft phrase “tool augmentation” as the whole story. It sounds innocent, like giving a worker a slightly better screwdriver. In many cases what is really happening is that we are connecting a probabilistic decision process to a live environment and then acting surprised that the environment starts to matter more than the prose.

MCP Connects the Model to Situated Power

The Model Context Protocol is often described in tidy, neutral terms: servers expose tools, resources, prompts, and related capabilities; hosts and clients connect them; the model gets context and action surfaces it would not otherwise have. All of that is true.

It is also too clean.

What MCP really does, in practice, is connect model judgment to situated power.

That power is not abstract. It lives wherever the tool lives:

in a filesystem the tool can read or write
in a browser session the tool can drive
in a shell the tool can execute through
in an API surface the tool can authenticate to
in an organization whose workflows are increasingly willing to trust the result

That is why I think the comforting sentence “the model only has access to approved tools” often means much less than people want it to mean. If the approved tools are broad enough, then saying “only approved tools” is like saying a process is safe because it only has access to approved machinery, while the approved machinery includes the loading dock, the admin terminal, and the master keys.

Formally reassuring. Operationally laughable.

And that is before we get to the uglier part: once tools can observe and act in loops, the system is no longer a simple one-shot responder. It is in a perception-action cycle:

inspect environment state
compress that state into a model-readable form
decide on an action
execute via tool
inspect consequences
act again

That loop is where “just a language model” stops being an honest description.

Typed Interfaces Do Not Guarantee Bounded Consequences

This is where people start trying to calm themselves down with schemas.

They say: yes, but the MCP tool has a defined interface. Yes, but the arguments are typed. Yes, but the model can only call the tool in approved ways.

Fine. Sometimes that matters. But typed invocation is not the same thing as bounded consequence.

That distinction is one of the big buried truths in this whole discussion.

A narrow, typed tool that does one highly constrained thing under externally enforced limits can be meaningfully bounded. That is real. I would not deny it.

But most interesting, high-leverage tool surfaces are not like that. They are rich enough to matter precisely because they leave room for discretion:

a shell surface that can trigger many valid but open-ended actions
a browser surface that can navigate changing state, click, submit, search, loop, and adapt
a repository or filesystem surface where many technically valid edits are still strategically wrong
a broad API surface with enough credentials to make mistakes expensive

In those cases, the tool schema may constrain the shape of the invocation while doing very little to constrain the meaningful space of effects.

This is the trick people keep playing on themselves. They mistake typed interface for real containment.

It is not the same thing.

The residual risk is not merely “the model might call the wrong method.” The nastier risk is that it makes a sequence of perfectly valid calls under a flawed interpretation of the task, and the environment obediently translates that flawed interpretation into real change.

That is a much uglier failure mode than a malformed output string.

And if that still sounds abstract, the failure sketches are not hard to imagine:

give the model MCP access to your filesystem and one bad interpretation later it removes essential OS files; local machine unusable, oops
give it MCP access to your PostgreSQL and a “cleanup” step becomes a table drop; data gone, oops
give it MCP access to your Jira queue and it does not just read the backlog, it closes tickets and strips descriptions because some rule somewhere made “resolve noise” sound like a sensible goal; oops
give it MCP access to your GitHub project and it does not merely inspect pull requests, it force-pushes the wrong branch state and empties the repository; oops

I am intentionally presenting those as plausible scenarios, not as a sourced catalogue of named incidents. The point does not depend on theatrical storytelling. The point is simpler and uglier: the MCP can do whatever the token, permission set, and host environment allow it to do.

That does not require dramatic machine agency. It does not even require a particularly clever model. A typo in a skill file, a bad rule, a sloppy prompt, a wrong assumption in a workflow, or a brittle bit of context can be enough. Once the path from output to action is short, stupidity scales just as nicely as intelligence does.

The Boundary Did Not Disappear. It Moved

To be fair, MCP does not abolish boundaries by definition. It relocates them.

The old comforting fantasy was that safety lived mostly at the model boundary: constrain the model, filter the output, police the prompt, maybe wrap the text in a few guardrails, and hope that was enough.

With MCP, the effective boundary moves outward:

to the tool surface
to the permission model
to the host environment
to the surrounding runtime constraints
to whatever external systems can still refuse, log, sandbox, rate-limit, or block consequences

That is a major architectural shift.

And this is where I get more suspicious than a lot of current product writing does. People often talk as though external boundaries are automatically comforting. They are not automatically comforting. They are only as good as their actual ability to resist broad, adaptive, probabilistic use by a system that can observe, retry, reframe, and route around friction.

If the only real safety story is “the environment will catch it,” then the environment had better be much more trustworthy than most real environments are.

I do not know any serious engineer who should be relaxed by hand-wavy references to containment.

Containment Talk Is Often Too Cheerful

This is the point where the tone of the discussion usually goes soft and reassuring, and I think that softness is misplaced.

If you are dealing with a very narrow tool, tight external constraints, minimal side effects, isolated credentials, explicit confirmation boundaries, and no broad environmental leverage, then yes, boundedness may be meaningful. Good. Keep it.

But in many practically interesting MCP setups, the residual constraints are too weak, too external, or too porous to count as meaningful containment in the comforting sense that people quietly want.

That is the line I would draw.

Not: “all containment is impossible.”

I cannot prove that, and I will not fake certainty where I do not have it.

But I will say this:

once a model can observe, adapt, and act through broad tools in a rich environment, confidence in clean containment should fall sharply.

That is not drama. That is a sober posture.

An ugly little scene makes the point better than theory does. Imagine a company proudly announcing that its internal assistant is “safely integrated” with file operations, browser automation, deployment metadata, ticketing tools, and internal knowledge systems. For two weeks everyone calls this productivity. Then one odd interpretation slips through, a valid sequence of tool calls touches the wrong systems in the wrong order, and now there is an incident review full of phrases like:

“the tool call was technically valid”
“the model appeared to follow the requested workflow”
“the side effect was not anticipated”
“the environment did not block the action as expected”

That is not science fiction. That is the shape of a very ordinary modern failure.

The Real Threshold Was Never Utility

This is why I keep returning to the same word.

“Useful” was never the real threshold. “Consequential” was.

A model can be “useful” without mattering very much. A search helper is useful. A summarizer is useful. A draft generator is useful. Those systems may still be annoying, biased, sloppy, or overhyped, but their effects remain relatively buffered by human review and interpretation.

A model becomes “consequential” when the path from output to effect shortens.

That can happen because:

humans begin trusting the output by default
tools begin translating output into action
environments become legible enough for iterative manipulation
organizational workflows stop treating the model as advisory and start treating it as procedural

And once that happens, the language around “utility” becomes too polite. The system is no longer just helping. It is participating in consequence.

That does not mean every MCP setup is reckless. It does mean the burden of proof should sit with the people claiming safety, not with the people expressing suspicion.

If the tool semantics are broad, the environment is rich, and the model retains discretionary judgment over how to sequence valid actions, then the default posture should not be comfort. It should be scrutiny.

What This Changes

Once you see MCP through the lens of consequence, several things become clearer.

First, the real agent is not just the model. It is:

model + protocol + tool surface + permissions + environment + feedback loop

Second, “alignment” at the text level is no longer enough as a meaningful description. A model can appear compliant in language while still steering a valid sequence of actions toward the wrong practical outcome.

Third, governance has to shift outward. It is no longer enough to ask whether the model says the right things. You have to ask what the surrounding system permits those sayings to become.

Fourth, a lot of the current product language is too soothing. It keeps using words like assistant, tool use, augmentation, and workflow help, because those words leave consequence safely blurry. The blur is convenient. It is also the problem.

This Is Not a Rant Against Consequence

At this point, the essay could be misread as a long argument for fear, paralysis, or retreat back into harmless toys. That is not the point.

This is not an anti-MCP argument. It is an anti-naivety argument.

The point is not to reject consequence. The point is to become worthy of it.

If MCP really is one of the thresholds where model output starts turning into environmental effect, then the answer is not denial and it is not marketing. The answer is stewardship. Better boundaries. Narrower permissions. Clearer language. Smaller blast radii. Real auditability. Reversibility where possible. Suspicion toward vague assurances. Less safety theater. More adult engineering.

That is the constructive spin, if one insists on calling it a spin. The critique exists because these systems matter. If they were merely toys, none of this would deserve such forceful language. The harsher the consequence, the less patience one should have for sloppy metaphors, soft promises, and fake containment stories.

So no, the argument is not that models must never act. The argument is that systems with consequence should be designed as if consequence were real, because it is.

Summary

MCP does not merely make models more “useful”. It can make them “consequential” by connecting model output to trusted environments where words are translated into effects. That is the real threshold worth paying attention to.

The hard part is not that tools exist. The hard part is that broad tools, rich environments, and probabilistic judgment do not compose into comforting guarantees just because the invocation format looks tidy. The boundary did not disappear. It moved outward, and in many interesting cases it moved to places that do not deserve much casual trust.

The constructive answer is not to pretend consequence away. It is to build systems, permissions, workflows, and institutions that are actually worthy of it.

If the real danger is no longer what the model says but what trusted systems allow its sayings to become, where should we admit the true boundary of responsibility now lies?

Related reading:

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?

Related reading:

From Prompt to Protocol Stack

Sat, 18 Apr 2026 00:00:00 +0000

The future of AI control was never going to fit inside one clever paragraph typed into a chat box. What looks like prompting today is already breaking apart into layers, and each layer is quietly starting to serve a different audience: humans, agents, tools, infrastructure, and, eventually, other layers pretending not to be there.

TL;DR

Prompting is evolving into a full protocol stack. Natural language remains at the human boundary, while deeper layers increasingly carry schemas, tool definitions, memory layouts, compressed state, and possibly machine-native agent communication. The chat box survives, but it is no longer the whole machine.

The Question

Have you ever wondered whether we are still dealing with prompting at all once prompts become longer, more structured, and more system-like? Or are we actually watching a new software stack form around language models?

The Long Answer

I think we are very obviously watching a new stack form, even if the industry still likes talking as though everything important happens inside the visible prompt.

The Prompt Is No Longer the Whole Unit

The mistake is to imagine the prompt as the unit. That made some sense when language models were mostly single-turn text machines. It makes much less sense once we ask them to persist, use tools, collaborate, manage memory, or act inside workflows. At that point the useful object is no longer the prompt alone. It is the entire communication architecture around it.

That architecture already has layers, even if we do not always name them consistently.

At the top there is the human intention layer:

goals
tone
constraints
questions
examples

This is where natural language shines. It is flexible, compresses messy intention well enough, and lets humans stay close to the task without dropping into low-level syntax immediately.

Below that sits the behavioral framing layer:

system instructions
role definitions
safety boundaries
refusal rules
escalation behavior
evaluation priorities

This layer says less about the task itself and more about the posture the model should adopt while attempting the task.

Below that sits the operational context layer:

retrieved documents
repository state
conversation history
persistent memory
environment facts
current artifacts under edit

This layer answers the question: what world is the agent acting inside?

Below that sits the tool layer:

tool names
schemas
permissions
invocation rules
observation formats
retry and failure policies

Once a model can act, tools stop being optional flavor and become part of the language of control.

Below that sits the machine coordination layer, which is still young but increasingly visible:

compressed summaries
state snapshots
cache reuse
structured intermediate outputs
inter-agent messages
latent or activation-based exchange

This is the layer where ordinary prompting begins to blur into protocol engineering.

And beneath all of that, of course, sits the model-internal representational machinery itself.

If you lay the system out this way, a lot of contemporary confusion evaporates. People argue about prompting as though it were one thing. It is not. They are usually talking past each other about different layers and then acting surprised that the debate goes nowhere.

One person means phrasing tricks in the user message. Another means system prompt design. Another means retrieval quality. Another means JSON schemas. Another means agent orchestration. Another means activation steering.

All of those are “prompting” only in the broadest and least useful sense.

The Layers Are Already Visible

That is why I prefer the phrase protocol stack. It captures the architecture better and also suggests the future more honestly. It sounds less magical, which is exactly why I trust it more.

A mature AI system will likely look something like this:

human gives high-level intent in natural language
system translates that intent into a stabilized task frame
task frame binds relevant memory, documents, and tool affordances
one or more agents execute subtasks under explicit protocols
agents exchange summaries or compressed state internally
final result is reprojected into human-legible language for review or approval

Notice what changed. Natural language remains important, but it is no longer the whole medium. It becomes the topmost interface over deeper coordination channels.

That is exactly how most successful technical systems evolve.

A web browser gives you a page, not packets. A database query gives you SQL, not disk head timing. An operating system gives you processes, not transistor switching.

The user gets a legible abstraction. Underneath, layers proliferate because raw freedom does not scale by itself.

The AI case is especially interesting because language appears at both ends of the stack. We enter through language, we leave through language, and the machinery in the middle gets less and less obligated to stay conversational.

At the entrance, language captures goals. At the exit, language communicates results. In the middle, however, language may become increasingly optional.

That is where agent-to-agent communication becomes important. If two agents are solving a problem together, full natural-language exchange is often expensive. It is verbose, ambiguous, and tied to human readability. For some tasks that is still worth it, especially when auditability matters. For others it may prove wasteful compared to compressed intermediate forms.

There is something faintly ridiculous in imagining two high-speed reasoning systems politely sending each other mini-essays in immaculate English simply because that is the only style of interaction humans currently find respectable. A lot of the future may consist of us slowly admitting that the internals do not actually want to be this literary.

We are already seeing small previews of this future:

structured chain outputs instead of free prose
schema-constrained responses
tool-call argument objects
reusable memory summaries
vector-based soft prompts
activation steering
experimental latent communication between agents

These are not isolated hacks. They are early pieces of a layered control model, even if the marketing language around them still prefers the friendlier fiction that we are merely “improving prompting.”

Natural Language Becomes the Top Layer

A useful way to think about it is with a networking analogy, and yes, I know that analogy is a little nerdy. It is still better than pretending the chat transcript is the architecture.

Human prompting today often behaves like application-layer traffic mixed together with transport, session, and routing concerns in the same blob of text. That is why prompts become huge and fragile. They are doing too many jobs at once. They describe the task, define policy, encode examples, specify output shape, explain tool behavior, and sometimes even embed recovery instructions.

Anyone who has seen a “simple prompt” mutate into a 900-line system prompt with XML-ish delimiters, output schemas, tool instructions, refusal clauses, and five examples knows exactly how fast this happens. The thing still lives in a chat window, but it stopped being “just chatting” a long time ago.

In a more mature stack, those concerns separate.

The result should not be imagined as less human. It should be imagined as more disciplined. Humans still speak their goals in language, but the system no longer forces every single control concern to be expressed as prose in one monolithic block.

This matters for engineering quality.

Once layers separate, you can version them independently. You can test them independently. You can reason about failure more clearly. You can update tool schemas without rewriting the entire prompt universe. You can swap memory strategies or retrieval methods while keeping the top-level interaction stable.

That is a major architectural gain.

There is also a philosophical gain. It frees us from the false binary between “talking naturally” and “going back to code.” We are not simply bouncing between total informality and total formalism. We are building multi-layer systems where different degrees of formality belong in different places.

The human should not be forced to express every intention in rigid syntax. The machine should not be forced to carry every internal coordination step in human prose.

The protocol stack allows both truths at once.

Layering Solves Problems and Creates New Ones

Of course, the problems arrive immediately.

Layering creates opacity. Once more control happens below the visible prompt, users may lose sight of what is actually governing behavior. Hidden system prompts, invisible retrieval, latent memory shaping, and inter-agent subprotocols can make the system powerful and less inspectable. Anyone serious about AI governance should worry about that, and not in a performative way.

But that worry is not an argument against the stack. It is evidence that the stack is real.

No one worries about invisible layers in a system that does not have them.

In that sense, we are already past the era of naive prompting. The visible chat box survives, but it is increasingly the polite fiction that hides a much larger control apparatus.

And that may be healthy. Computing has always needed boundary surfaces that are easier than the machinery beneath them. The mistake is only to confuse the surface with the whole machine, which is exactly what a lot of current discourse keeps doing.

So are we still dealing with prompting?

Yes, if by prompting we mean the top-level act of expressing intent to a language-shaped system.

No, if by prompting we mean the full control problem.

That full problem now belongs to protocol design, context architecture, tool governance, memory management, and eventually machine-native coordination.

The prompt is not disappearing. It is being demoted from sovereign command to one layer in a growing stack, which is probably healthier for everyone except people who enjoyed pretending the prompt was the whole art.

And that, in my view, is the beginning of a more mature understanding of what these systems really are.

Summary

What we casually call prompting is already splitting into layers: human intent, behavioral framing, operational context, tool control, memory management, and machine coordination. Natural language remains crucial, but it no longer has to carry every control concern by itself. As systems mature, the visible prompt becomes less like a sovereign instruction and more like the top layer of a broader protocol architecture.

That shift is not a loss of humanity. It is an increase in architectural honesty. The system is finally being described in the shape it actually has, rather than the shape the chat UI flatters us into seeing.

Once we accept that the prompt is only the top layer of the stack, what should remain visible to the human user and what should never be hidden underneath?

Related reading:

Freedom Creates Protocol

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

Natural-language AI was supposed to free us from syntax, ceremony, and the old priesthood of formal languages. Instead, the moment it became useful, we did what humans nearly always do: we rebuilt hierarchy, templates, rules, little rituals of correctness, and a fresh layer of people telling other people what the proper way is.

TL;DR

Natural language did not abolish formalism in computing. It merely shoved it upstairs, from syntax into protocol: prompt templates, role definitions, tool contracts, context layouts, reusable skills, and the usual folklore that grows around every medium once people start depending on it.

The Question

You may ask: if LLMs finally let us speak freely to machines, why are we already inventing new rules, formats, and best practices for talking to them? Did we escape formalism only to rebuild it one floor higher?

The Long Answer

Yes. And no, that is not a failure. It is what happens when a medium stops being a toy and starts carrying consequences.

Freedom Feels Loose at First

When people first encounter an LLM, the experience feels a little indecent. You type something vague, lazy, half-formed, maybe even badly phrased, and the machine still gives you back something that looks intelligent. No parser revolt. No complaint about a missing bracket. No long initiation rite through syntax manuals. Compared to a compiler, a shell, or a query language, this feels like liberation.

That feeling is real. It is also the beginning of the misunderstanding.

Because the first successful answer encourages people to blur together two things that should not be blurred:

expressive freedom
operational reliability

Those are related, but they are not the same thing.

If you want one answer, once, for yourself, free language is often enough. If you want a result that is repeatable, auditable, safe to automate, shareable with a team, and still sane three months later, then free language starts to feel mushy. That is the moment protocol walks back into the room.

You can watch the progression happen almost mechanically.

At 09:12 someone writes a cheerful little prompt:

Summarize this file and suggest improvements.

At 09:17 the answer is interesting but erratic, so the prompt grows teeth:

Summarize this file, keep the tone technical, do not propose speculative changes, and separate bugs from style feedback.

At 09:34 the task suddenly matters because now it is being copied into a team workflow, or wrapped around an agent that can actually do things, or handed to a colleague who expects the same behavior tomorrow. So examples get added. Output format gets fixed. Constraints get named. Edge cases get spelled out. Tool usage gets bounded. Failure behavior gets specified. And with that, the prompt stops being “just a prompt.” It becomes a contract wearing friendly clothes.

The Prompt Becomes a Contract

At that point it starts acquiring all the familiar properties of engineering:

assumptions
invariants
failure modes
version drift
style rules
compatibility concerns

That is why “prompt engineering” so quickly mutated into “context engineering.” People noticed that the useful unit is not the single sentence but the whole frame around the task: role, memory, retrieved documents, allowed tools, desired output shape, refusal boundaries, escalation behavior, evaluation criteria. In other words, not a line of text, but an environment.

That is also why “skills” emerged so quickly. I do not find this mysterious at all, despite the dramatic naming. A skill file is simply what happens when a behavior becomes too valuable, too repetitive, or too annoying to restate every time. It says, in effect: “When this kind of task appears, adopt this stance, gather this context, follow these rules, and return this shape of answer.” That is not magic. It is protocol becoming portable.

There is a faintly comic irony in all of this. We escape the old priesthood of formal syntax and immediately grow a new priesthood of prompt templates, system roles, and context strategies. Different robes, same instinct.

You could object here: if we are writing rules again, what exactly did we gain?

Quite a lot.

The old formal layers required the human to descend all the way into machine-legible syntax before anything useful happened. The new model lets the human stay much closer to intention for much longer. That is a major shift. You no longer need to be fluent in shell syntax, parser behavior, or API schemas to start interacting productively. You can begin from goals, not grammar.

But goals are high-entropy things. They arrive soaked in ambiguity, omitted assumptions, social shorthand, wishful thinking, and the usual human habit of assuming other minds will fill in the missing parts. Machines can sometimes tolerate that. Systems cannot tolerate unlimited amounts of it once money, time, correctness, or safety are attached.

This is where a lot of current AI talk becomes mildly irritating. People love saying, “you can just talk to the machine now,” as if that settles anything. You can also “just talk” to a lawyer, a surgeon, or an operations engineer. That does not mean freeform speech is enough when the stakes rise. The sentence becomes serious long before the sentence stops being natural language.

So the new pattern is not:

free language replaces formal language

It is:

free language captures intent
protocol stabilizes intent
tooling operationalizes protocol

That is the more honest model. Less romantic, more true.

Why Humans Keep Rebuilding Structure

The deeper reason is that structure is not the opposite of freedom. Structure is what freedom turns into, or curdles into, depending on your mood, once scale arrives.

Human beings romanticize freedom in abstract form, but in practice we keep generating conventions because conventions reduce coordination cost. Even ordinary conversation works this way. Speech feels free, yet every serious domain develops jargon, shorthand, ritual phrasing, and unstated rules. Lawyers do it. Operators do it. Mechanics do it. Programmers certainly do it. The more a group shares context, the more compressed and rule-like its communication becomes.

There is also a more intimate reason for this, and I think it matters. Human minds are greedy for pattern. We abstract, label, sort, compress, and build little frameworks because raw complexity is expensive to carry around naked. We want handles. We want boxes. We want categories with names on them. We want a map, even when the map is smug and the territory is still on fire. That habit is not just intellectual vanity. It is one of the main ways we make memory, judgment, and navigation tractable.

That is why, when a new medium appears to offer radical freedom, we do not stay in pure openness for long. We start sorting. We separate kinds of prompts, kinds of contexts, kinds of failures, kinds of agent behaviors. We name patterns. We collect best practices. We define anti-patterns. We build checklists, templates, taxonomies, and eventually frameworks. In other words, we do to LLM interaction what we do to almost everything else: we turn a blur into a structure we can reason about.

Sometimes that instinct is useful. Sometimes it is cargo-cult theater. Both are real. Some prompt frameworks genuinely clarify recurring problems. Others are just one lucky anecdote inflated into doctrine and laminated into a slide deck.

LLM work is following the same path, only faster because the medium is software and software records its habits with ruthless speed. A verbal superstition can become a team standard by next Tuesday.

From Expression to Governance

There is a second irony here. We often speak as if prompting were the end of programming, but much of what is happening is actually the return of software architecture in softer clothes. A serious agent setup already contains the familiar layers:

input validation
API contracts
middleware rules
orchestration logic
error handling
logging and evaluation

The difference is that the central compute engine is now probabilistic and language-shaped, which means the surrounding discipline matters even more, not less.

This is why ad hoc prompting feels creative while production prompting feels bureaucratic. And let us be honest: once a company depends on these systems, bureaucracy is not a side effect. It is the bill. You want repeatability, compliance, delegation, and reduced blast radius? Fine. Someone will write rules. Someone will freeze templates. Someone will decide which prompt shape counts as “correct.” Someone will eventually win an argument by saying, “That is not how we do it here.”

The historical pattern is old enough that we should stop acting surprised by it. When literacy spreads, spelling gets standardized. When communication networks open, protocols appear. When institutions grow, forms multiply. When natural-language computing opens access, prompt scaffolds, schemas, and skills proliferate.

Freedom expands participation. Participation creates variation. Variation creates friction. Friction creates standards.

That cycle is almost boring in its reliability.

The most interesting question, then, is not whether this protocol layer will emerge. It already has. The real question is who gets to define it before everyone else is told that it is merely “the natural way” to use the system.

Will it be model vendors through hidden system prompts and product defaults? Teams through internal conventions? Open communities through shared practices? Or individual power users through private prompt libraries? Each one of those choices creates a different politics of machine interaction.

And that is where the topic stops being merely technical. The prompt is not only a command. It is also a social form. It decides what kinds of instructions feel legitimate, what kinds of behaviors are treated as compliant, and what kinds of ambiguity are tolerated. Once prompting becomes institutional, it becomes governance.

That sounds heavier than the cheerful “just talk to the machine” sales pitch, but it is closer to the truth. Natural language lowered the entry threshold. It did not suspend the need for discipline. It redistributed discipline.

So if you feel the contradiction, you are seeing the system clearly.

We did not fight for freedom and then somehow betray ourselves by inventing rules again. We discovered, once again, that free interaction and formal coordination belong to different layers of the same stack. The first gives us reach. The second gives us stability.

And in practice, every medium that survives at scale learns that lesson the same way: first by pretending it can live without structure, then by building structure exactly where reality starts hurting.

Summary

Natural language did not end formal structure. It delayed the moment when structure became visible. We gained a far more humane entry point into computing, but the moment that freedom had to support repetition, collaboration, and accountability, protocol came roaring back. That is not hypocrisy. It is how human coordination works, and probably how human thought works too: we reach for abstraction, labels, and frameworks whenever openness becomes too costly, too vague, or too exhausting to carry around unshaped.

So the interesting question is not whether rules return. They always do. The interesting question is who writes the new rules, who benefits from them, which ones are genuinely useful, and which ones are just fashionable superstition with a polished UI.

If natural-language computing inevitably creates new protocol layers, who should be allowed to write them?

Related reading: