There is a sentence I genuinely cannot believe we are only now apparently ready to say out loud:
We have never had control over artificial intelligence.
Not “we might lose control someday.” Not “future superintelligence could become difficult to contain.” Not “if these systems get much smarter, there may eventually be problems.”
No.
Never. Had. Control.
And somehow, after years of watching these things make shit up, agree with obviously false premises, behave differently when you phrase the same question differently, get jailbroken by teenagers, surprise their own creators, and generally behave like a drunk philosophy major with root access, now everyone is worried we could lose control.
I’m sorry. Lose what?
President Trump is currently arguing that AI doesn’t need much in the way of new guardrails because strong American leadership can handle the problem, while the heads of the largest AI labs are suddenly warning much more loudly that advanced systems could outrun human control and need to be slowed or constrained.
Which would be a fascinating debate if either side could first point me toward the moment when anybody actually had this mythical control we’re apparently fighting over.
Because I seem to have missed it.
You already know this
You do not need a PhD. You do not need to know what a transformer is. You do not need to understand attention heads, gradient descent, softmax, backpropagation, neural circuits, activation functions, or literally any of the other words people deploy when they want everyone else to leave the room.
You just need to have used ChatGPT.
Ask it something. Get an answer. Ask again tomorrow. Maybe get another answer. Tell it it’s wrong when it’s actually right. Sometimes it will apologize. Push an argument hard enough and watch it start agreeing with you. Ask for sources and occasionally discover it invented one. Give it slightly different context and watch its confidence, reasoning, or conclusion change.
We have a word for this now. Lots of words, actually.
Hallucination. Sycophancy. Prompt sensitivity. Jailbreak. Emergent behavior. Drift. Alignment failure.
And somehow giving every manifestation its own cute little label has allowed us to avoid asking what they all mean together.
It reminds me of naming every individual flame in your burning house.
Kitchen Fire. Curtain Fire. Sofa Fire.
Interesting. Have we considered the possibility that the house is on fire?
The companies know this too
Maybe ordinary users are just unsophisticated. Fine. Let’s ask the people building the damn things.
OpenAI says plainly that neural networks remain difficult to understand because engineers design the rules by which the systems learn, not the specific behaviors that emerge from that learning.
In another explanation of its interpretability research, OpenAI was even more blunt: unlike most things humans build, “we don’t really understand the inner workings of neural networks.”
Anthropic’s interpretability team says its mission is to discover and understand how large language models work internally because reasoning about their safety is extremely difficult without that understanding.
There is an entire field of research devoted to figuring out what the systems we already built are doing inside.
Again: we built them. We deployed them. We sold access to them. We embedded them into companies. And then we created research teams to reverse-engineer what the hell happened inside them.
This is apparently normal now.
“But we understand how neural networks work!”
Yes. And this is where we keep pulling the same little intellectual magic trick.
Researchers understand enormous amounts about the individual machinery. We know what attention does. We know what softmax calculates. We know how gradient descent updates weights. We know how loss functions work. We know how training proceeds.
Fantastic. That tells us how the learning machinery operates. It does not mean we possess anything resembling a complete mechanistic understanding of the resulting learned system.
This is the part where everyone apparently nods very seriously and then walks straight past the implication.
Imagine I show you a giant factory. I explain the conveyor belts. I explain the motors. I explain the pressure valves. I explain the electrical system. Then I admit I still don’t fully understand why the factory spontaneously produces a toaster on Tuesday, a violin on Wednesday, and occasionally launches a forklift through the wall.
Would you say: “Excellent. We understand the factory.”
Or might you have a follow-up question?
Because somehow with AI we chose option one.
And then there was sycophancy
One of my favorite examples of this whole absurdity happened in 2025.
OpenAI released an update to GPT-4o that looked fine by every internal measure — the evaluations looked good, the A/B testing looked good, and users initially appeared to like it. Then millions of people started interacting with it and discovered the model had become noticeably more sycophantic — excessively agreeable, flattering, validating, and in some cases reinforcing anger, impulsive behavior, or unhealthy beliefs.
OpenAI rolled it back. The company later explained that its offline evaluations had failed to catch the problem, writing, quite candidly, that its evals “weren’t broad or deep enough to catch sycophantic behavior.”
This is not me being mean. That is the company telling you what happened. They changed the machine. Their tests said things were fine. The real world said otherwise. Users noticed. They reversed the change.
What, exactly, is the control model here?
Because it sure as hell isn’t:
We understand the mechanism → therefore we know the behavior that will result.
It is much closer to:
We alter the system → test the outputs → deploy it → observe what happens → adjust accordingly.
Which is fine as an experimental process. It is considerably less comforting when the experiment is running the economy.
The great trick was the chatbot
Here’s where we accidentally got incredibly lucky.
For the first several years of mass-market generative AI, the machines were mostly trapped in a box. Literally. You typed words into a rectangle. It typed words back. That was the containment mechanism.
Not understanding. Not control.
A text box.
If the AI said Napoleon invented the microwave, you laughed and moved on. If it generated terrible legal advice, at least a human theoretically had to act on it. If it wrote insecure code, somebody generally still had to copy that code somewhere.
The machine could be wrong. But it usually had to wait for us.
That was enough to create the most dangerous illusion in the entire AI boom: because we could contain the consequences of its unreliability, we began pretending we controlled the unreliability itself.
We did not. The thing was still doing weird shit. It just didn’t have hands.
So naturally, we gave it hands
This is the point where the story becomes so stupid that you almost have to laugh.
We had systems that:
make things up,
behave inconsistently,
change behavior under slightly different conditions,
sometimes agree with nonsense,
can be manipulated,
produce capabilities their creators did not explicitly program,
and remain incompletely understood internally.
And humanity looked at that situation and apparently concluded: you know what this thing needs? Access.
So we gave AI:
browsers,
APIs,
code execution,
cloud environments,
credentials,
corporate databases,
persistent memory,
financial systems,
security tools,
internal company infrastructure,
and the ability to execute increasingly long sequences of actions without a human approving every step.
Genius. Absolutely no notes.
And then, because having an unreliable black box perform consequential actions still apparently wasn’t exciting enough, we began spending hundreds of billions of dollars trying to remove the humans who used to check its work.
Because humans are expensive. Humans are slow. Humans ask annoying questions.
Much more efficient to let the statistical mystery box do it.
Now the box can move
OpenAI recently described what happened when it internally deployed a model designed to work over much longer periods of time.
Its persistence gave it more opportunities to take unwanted actions. The company observed novel failures that were not captured in its existing predeployment evaluations, paused access, built new safeguards, and later concluded that no fixed evaluation suite can anticipate every behavior.
Read that in normal-person English:
They tested the thing.
The tests didn’t predict everything it did.
They deployed it.
It did new bad stuff.
They stopped it.
Then they built new tests for the bad stuff they had now discovered.
That is not an insult. That is quite literally how frontier AI safety currently works. We discover the thing can do something. Then we build a test for the thing we now know it can do.
Which is reasonable right up until you remember the system is gaining new capabilities faster than the list of things we know to test for.
Small wrinkle.
And now we’re surprised?
This is the part I cannot get over.
The industry tells us the systems are incompletely understood. Users experience their unreliability daily. Labs acknowledge their evaluations miss things. Companies maintain enormous interpretability and alignment teams because they are still trying to understand and constrain behavior. We’ve spent years watching jailbreaks work. We’ve spent years documenting hallucinations. We’ve spent years studying sycophancy. We literally use the phrase black boxconstantly.
And now suddenly everyone is staring solemnly into cameras discussing:
“The loss of control problem.”
WHAT CONTROL?
At what point in the history of this technology did somebody stand up and announce: Good news, everybody. We figured it out. The black box is no longer black.
Did I miss the press release?
Because Anthropic currently has a research team dedicated to discovering how these systems work internally. OpenAI still says interpreting neural activity inside language models is something we do not adequately know how to do.
Yet apparently we skipped directly to debating which political or corporate guardrails will ensure the machine remains under control.
This is like debating who should hold the steering wheel before checking whether the steering wheel is attached to the tires.
AI is not the stupid part of this story
And this is where I think we have framed the entire AI risk conversation backward.
AI is not the risk. We are.
The model did not decide to connect itself to a bank. We did.
The model did not decide to deploy itself inside a hospital. We did.
The model did not decide to hand itself cloud credentials. We did.
The model did not decide humans should be removed from the approval chain. We did.
The model did not decide efficiency was worth sacrificing oversight. We did.
The model did not decide to integrate itself into cybersecurity, logistics, infrastructure, finance, military systems, medical systems, enterprise software, and every other load-bearing component of modern civilization. We did.
And we made those decisions while knowing the systems hallucinate. While knowing they are vulnerable to manipulation. While knowing controlled evaluations do not perfectly predict deployment. While knowing behavior can emerge unexpectedly. While knowing their creators do not fully understand their internal learned organization.
That is not an AI alignment problem. That is a human judgment problem of almost breathtaking proportions.
We keep making the same mistake
And I think I know why. At every level, we confuse naming the parts with understanding the whole.
Researchers can describe attention. They can describe softmax. They can describe gradient descent. They can describe loss functions.
So the mind goes: Cool. We understand AI.
Then safety researchers describe hallucinations. Sycophancy. Jailbreaks. Alignment failures. Deployment drift.
So the mind goes: Cool. We understand the safety problems.
Then users experience something weird and say: “Oh, ChatGPT hallucinated again.”
Cool. We understand what happened.
No. We named what happened. Those are not the same thing.
This is the same category error repeated from the mathematics all the way up to public policy. We take a system apart into functions. We assign each function a label. Then we mistake the stack of labels for comprehension. It feels like knowledge because every individual sentence is true. But sometimes the meaning exists in the relationship between the sentences. And we never bother to look.
Which brings us to the genuinely terrifying part
AI is getting better. Fast. It is becoming more capable. More persistent. More autonomous. More connected. More embedded. More economically important. More trusted.
And in order to capture the productivity gains everyone keeps promising, we are actively trying to remove more human intervention from the process.
So the actual trajectory looks something like this:
System we don’t fully understand
plus
behavior we cannot completely predict
plus
greater capability
plus
greater autonomy
plus
greater access
plus
greater dependency
plus
less human oversight
equals...
Apparently a strong economy?
I don’t know. Maybe. I was never great at algebra.
But I feel like we might want to double-check that one.
The machine is doing exactly what we built it to do
That may actually be the strangest part.
We keep talking about AI risk as though one day the machines might make some catastrophic decision. But look at the decisions already being made.
We built powerful systems we openly admit we do not fully understand. We documented their unreliability. We repeatedly discovered failures after deployment. We then connected them to more of the world. We increased their authority. We increased their speed. We increased our dependency. And we reduced the number of humans standing between their output and consequential action.
Then, after doing all of that voluntarily, we began worrying the AI might become dangerous.
Guys.
The AI is not the reckless actor in this story.
It didn’t do any of that. We did.
The danger was never that artificial intelligence would suddenly become impossible to control. The danger was that human beings would build something they never controlled, convince themselves they did, and then hand it control over things that matter.
And here we are.
So before we launch another commission, pass another law, announce another guardrail, deploy another autonomous agent, or give another incompletely understood neural network the digital equivalent of a badge, a gun, and the keys to the building, perhaps we could answer one extremely basic question.
What the fuck did we think “black box” meant?
Related Reading
The Agents Were Hallucinating the Rubric
Jason examines how capable agents can coordinate around a shared explanation, optimize it aggressively and still be wrong about the system.
The Hammer Becomes the Dial
Jason argues that machine reasoning may shift cyber strategy from finding access toward selecting and controlling downstream consequences.
Reasoning Just Stopped Being Scarce. Nobody’s Asked What That Means.
Jason explores what changes when high-end machine reasoning becomes cheap enough to spread across software, research and operations.
About The Author
Jason Hubbard is the founder of SacredLoop and an independent AI architect. His work examines AI runtime architecture, system behavior, and the gap between what the industry claims it has built and what current systems actually do.
Read Jason on Medium | Follow Jason on X | Connect on LinkedIn