There are moments in the history of science when an idea stops being merely clever and the universe, despite its better judgement, appears to agree with it.

Einstein had one of those moments in 1919.

A solar eclipse darkened the sky, Arthur Eddington photographed stars near the Sun, and their apparent positions shifted roughly where general relativity said they ought to shift. The universe had been handed a difficult theoretical paper and, against all reasonable expectations, returned LGTM.

J. L. Austin never got his eclipse.

Neither did John Searle.

They spent an unreasonable amount of time thinking about something most of us regard as completely ordinary: people saying things to one another.

Their troublesome idea was that language isn’t simply a mechanism for describing reality.

Language does things. Which is troublesome because it makes sense, yet people don’t want to believe it.

“I promise.”

“You’re fired.”

“I accept.”

“Deploy it.”

“Meet me at the bar.”

These aren’t merely sentences carrying information from one damp somewhat functional brain to another. They are actions. Under the right circumstances, saying the thing is doing the thing.

Austin called these speech acts. Which sounds weird, but by sounding weird, actually proves the point.

Then, decades later, humanity spent several billion dollars, consumed a noticeable fraction of the world’s electricity, accumulated warehouses full of GPUs, and built machines whose principal means of interacting with us is…

language.

And somehow we decided the important part was the prompt.

This is rather like watching Eddington’s eclipse and becoming fascinated with the camera strap.

The Eclipse#

Large Language Models are interesting because they appear to demonstrate something much larger than “computers can generate convincing text.”

We’ve had computers generating text for a long time. ELIZA was doing a sufficiently disturbing version of it in the 1960s.

The interesting thing happens when language becomes the interface between intent and action.

Consider:

Investigate why checkout is failing.

That sentence doesn’t primarily describe anything.

It is a request.

It establishes an objective. It implies a subject. It carries expectations about authority. It assumes context shared between speaker and listener. It establishes conditions under which the request can be considered satisfied.

And now an LLM can receive that utterance, inspect telemetry, search logs, examine source code, read tickets, form hypotheses, call tools, and return evidence.

The sentence has caused things to happen.

Austin would recognize the basic shape immediately.

The remarkable part isn’t that the machine understands English in whatever metaphysical sense we’re currently fighting about on the Internet.

The remarkable part is that it doesn’t necessarily have to.

The speech act still works.

That should bother us a little. Maybe more than a little if the speech act can control production.

It should also make us reconsider how we’re building AI systems.

We Really Should Have Seen This Coming#

At this point I should probably surrender the name Half-Fast DevOps.

None of this should be a revelation in 2026.

Especially not to anyone who watches sports.

We have been watching natural-language actors perform consequential speech acts for more than a century.

We call them officials. Often, we call them harsher things that would really upset their mothers.

Consider a baseball umpire.

A pitch arrives.

The umpire says:

Strike!

Something important has happened.

The umpire isn’t merely describing the pitch.

The umpire has made a call.

Without the call, there is no official strike. There is only a baseball moving through space, accompanied by several thousand people who have suddenly become experts in geometry.

The call creates an institutional fact within the game.

The count changes.

The batter’s strategy changes.

The pitcher’s strategy changes.

With two strikes already recorded, the batter may cease being a batter entirely and begin the long philosophical walk back toward the dugout.

Now suppose our increasingly sophisticated collection of cameras, tracking systems, geometry, statistics, replay, and angry people on television concludes that the ball passed six inches outside the rulebook strike zone.

This does not mean the umpire failed to make a strike call.

Quite the opposite.

The strike exists in the game ONLY because the umpire made it.

What we can say is that the call did not accurately represent the physical event we subsequently measured.

Those are different things.

There is the event.

There is the utterance.

There is the institutional consequence of the utterance.

And there is our later evaluation of how well that utterance corresponded with observable reality.

Now we’re doing speech-act theory.

And suddenly Large Language Models become considerably less mysterious.

An LLM says:

The deployment caused the outage.

That utterance can become consequential.

A ticket gets updated.

An incident changes state.

Someone rolls back a deployment.

Dave gets paged during dinner.

None of those consequences prove that the deployment actually caused the outage.

The utterance and reality are separate things.

Which means the problem with LLM hallucination isn’t simply that models sometimes produce statements that fail to correspond with reality.

Humans have been doing that since approximately five minutes after language was invented.

The interesting engineering problem is:

What authority does the utterance have, what consequences can it produce, and how can we evaluate it against reality?

Sports figured this out long before AI.

Officials have defined authority.

Their calls have defined consequences.

Some calls can be reviewed.

Evidence can be consulted.

Calls can sometimes be overturned.

Different officials have different jurisdictions.

There are procedures governing disagreement.

And eventually, because civilization has limits, somebody declares the game over and everyone goes home angry.

This is governance.

It doesn’t require the official to possess perfect knowledge of reality.

It requires us to understand the relationship between observation, declaration, authority, consequence, evidence, and review.

Those are precisely the concepts we need for LLM systems.

The surprise shouldn’t be that LLMs sometimes produce utterances that don’t correspond with reality.

The surprise should be that anyone expected linguistic actors to behave differently. As much as people hate officials, I’m baffled nobody else seems to get this.

We Keep Building Typewriters#

Most LLM systems still begin with something resembling this:

Human → Prompt → LLM → Text

This makes perfect sense if what you’ve accidentally invented is an extremely expensive typewriter.

But once the model can use tools, retrieve information, interact with systems, modify files, create tickets, execute programs, and initiate other processes, text generation stops being the interesting abstraction.

The interesting abstraction becomes:

Speaker
   │
   │ intent
   ▼
Speech Act
   │
   ├── context
   ├── authority
   ├── constraints
   ├── expectations
   └── evidence
   │
   ▼
Actor
   │
   ▼
World
   │
   ▼
Result
   │
   └──── becomes context for the next act

Now something peculiar has happened.

The LLM isn’t the architecture.

The conversation is.

And conversation, properly understood, isn’t merely an exchange of strings.

It’s a sequence of consequential acts.

Enter SpeechActv2#

This is why I’ve been working on something I call SpeechActv2.

The name sounds considerably more important than the software, which is generally a healthy sign.

SpeechActv2 starts with a deliberately boring proposition:

Represent what we want an AI system to do as an explicit speech act rather than hiding the entire contract inside a prompt.

Instead of:

"Please investigate why production is broken."

we represent something closer to:

act: investigate
subject: production-api

goal:
    determine cause of elevated 5xx responses

constraints:
    - do not modify production
    - conclusions require observable evidence

context:
    incident: INC-4821

expected:
    - findings
    - evidence
    - confidence
    - recommended-next-act

Notice what we’ve done.

We haven’t made the LLM smarter.

We’ve made the conversation less stupid. (trademark pending)

The act can be logged.

It can be reviewed.

It can be rejected.

It can be replayed.

It can be handed to another model.

It can be handed to a shell script.

It can be handed to Dave.

Dave has been maintaining the Oracle installation since the Clinton administration and, unlike your frontier model, already knows somebody accidentally filled /var again.

The actor is replaceable.

The act remains.

The Machine Isn’t the Point#

This may ultimately be the mistake we’re making with LLMs.

We’re staring at the machine.

How many parameters?

Which model?

What benchmark?

How large is the context window?

Which company currently possesses the sacred weights?

Those questions aren’t meaningless. They’re simply questions about implementation.

The more interesting question is what happens when language itself becomes a practical control plane for computing.

Not commands.

Not APIs.

Not buttons.

Intent expressed through language, transformed into actions, whose consequences become the context of subsequent language.

Act.

Result.

Observation.

Next act.

Again.

Again.

Again.

There is something almost Kerouac-like about it: the conversation moving forward because it cannot remain where it was, each utterance carrying the accumulated consequences of all the utterances before it.

And there is something deeply Camusian about spending seventy years building increasingly elaborate programming languages only to arrive at:

"Can you find out why the website is broken?"

Perhaps the computer revolution ends where human civilization began.

Two entities standing in the darkness, trying to tell each other what they want.

One of them is silicon.

The other has a Jira account.

It is not immediately obvious which has suffered more.