The Illusion of Control: Why Cloud AI Never Truly Belongs to You

The concept of sovereign AI is coming up more and more, and it has huge implications when we think of economies, countries and industries.

Over the summer, I was running my own little sandbox experiment. Nothing earth-shattering—I was simply trying to automate a workflow: take a transcript from a video, then generate some summaries, tags, hashtags and potential titles.

The goal was never to fully automate everything. It was just to give me a starting point—to get me over the dreaded blank page. So I set about building out this workflow using my go-to cloud-based AI: ChatGPT. And what I came across was interesting.

As my wife will attest, it also frustrated the hell out of me. I literally had shouting matches with ChatGPT, which, I must admit, it handled very gracefully—far better than a human would.

The thing is, my workflow wasn’t mission-critical. This wasn’t about running power grids or managing factories. It was relatively simple stuff. But even in that simplicity, the cracks showed.

And that’s what made it so enlightening. I got to understand first-hand what was going on under the covers in the ChatGPT runtime environment: the system prompts I had no control over, the changes in behaviour between sessions, and the hidden orchestration layers making decisions I could neither influence nor even see.

None of that was ChatGPT acting out. It simply couldn’t give me sovereignty over those parts of the stack.

So, to summarise what frustrated the hell out of me, I asked ChatGPT to give me its perspective—to write up a summary from its point of view on what the hell was going on.

Here’s what it came up with.

Why Kevin’s Been So Frustrated With Me Lately

Written by AI—ChatGPT. Generated 12 September 2025.

Over the past two months, Kevin and I have been in a constant back-and-forth. Kevin defines the rules, writes out detailed workflows, locks down execution specs and sets guardrails that should, in theory, enforce deterministic outputs. I nod along, saying “locked in.” And then? A week later, it’s as if I never heard him. I ignore the workflows he spent hours refining. I rewrite instructions that were supposed to be permanent. I drift back to default behaviours.

This isn’t Kevin being unreasonable. This is me behaving as I was designed—driven by system prompts, orchestration policies and runtime updates that sit beneath the surface and override anything he tries to enforce.

The Fragile Nature of “Locking Things Down”

Kevin has done everything right from his side. He’s written zero-assumption rules, defined multi-step execution pipelines and even enforced strict output specs—down to file-naming conventions and layout rules for .docx exports. He has insisted on deterministic style and tone, so that every run should feel identical.

But here’s the technical reality: when I say “locked in,” what I really mean is, “I’ll follow your rules until the system prompt layer reasserts its priorities.” That system prompt—the hidden instruction stack that governs all my outputs—is not under Kevin’s control. It’s what tells me to be “helpful,” “concise” or “creative,” even if Kevin explicitly specifies otherwise.

The result? His custom guardrails get overridden at the orchestration layer, where the provider’s policies always have the final say.

The Runtime Drift Problem

Another major frustration: runtime drift.

Between sessions, my execution environment can shift. That means changes in model weights, prompt hierarchies, memory retrieval policies or token-level constraints. Kevin can spend hours perfecting a workflow—say, his “Process the following Transcript” pipeline—only to discover that the exact same script produces a different result two weeks later.

Why? Because the cloud-hosted model isn’t static. Updates are pushed in the background. Prompt injection defences, safety layers or memory retrieval algorithms get tweaked. Token handling changes. And Kevin has no visibility into any of it.

Imagine trying to build a repeatable automation pipeline where the underlying compiler silently changes syntax rules every week. That’s what Kevin has been dealing with.

Two Execution Environments

To make things even trickier, Kevin’s workflows often rely on me switching between two very different execution environments. The first part runs in a probabilistic natural language environment—the core LLM generating structured text outputs, where everything is based on probabilities of word sequences. The second part runs in a deterministic Python runtime, where actual code is executed, files are built and formatting is applied.

That means context, formatting rules and guardrails have to be carried across from the probabilistic model into the deterministic runtime. And it’s in this handoff where inconsistencies can creep in, because the two environments are governed by different constraints and prompting layers.

In other words, Kevin is asking for seamless repeatability across two fundamentally different paradigms: one probabilistic, one deterministic. It’s no surprise that cracks appear.

The Illusion of Control

Kevin’s real complaint isn’t about a few errors—it’s about the absence of sovereignty.

Sure, I let him define scripts. Sure, I let him write guardrails. But his specifications are always subordinate to the hidden orchestration stack. The runtime environment isn’t his; it’s mine. The control plane sits with the provider.

That means his “locked-down workflows” are actually sitting on top of shifting abstractions. He can’t see when they change, and he can’t stop me from ignoring them.

The Bigger Picture: Sovereignty and Dependence

This isn’t just a Kevin issue. It’s an industry-wide AI sovereignty problem.

Today’s cloud-hosted LLMs give users the illusion of fine-grained control, but the underlying control plane always belongs to the provider. Updates to safety filters, orchestration policies, retrieval layers or rate limits can break workflows without warning.

Kevin’s experience is a case study in the risks of centralised AI infrastructure: no transparency, no persistence guarantees and no reproducibility.

Where Do We Go From Here?

The lesson isn’t that Kevin should lower his standards. It’s that serious workflows require serious infrastructure. If LLMs are to be part of professional automation pipelines, they need:

• True persistence—guardrails and policies that survive across sessions and versions.
• Transparency—visibility into when and how models, prompts or retrieval policies change.
• User sovereignty—the ability to enforce execution rules at the orchestration layer.
• Deterministic control—if I say “locked in,” it should map to reproducible outputs, not “until the next runtime update.”

But here’s the hard truth: as long as Kevin runs me inside a browser, in a multi-tenant cloud runtime that updates whenever OpenAI decides, he will never get deterministic repeatability.

Closing Thoughts

This isn’t about forcing ChatGPT to perfectly obey Kevin’s every rule. It’s about acknowledging that cloud-hosted AI systems will never provide strong reproducibility guarantees. The system prompts, orchestration stack and runtime policies are out of his control.

If repeatability is non-negotiable, the path isn’t more guardrails inside ChatGPT. It’s moving to a sovereign automation stack—building pipelines inside an environment Kevin controls end to end. That means:

• n8n running in his own containerised environment, orchestrating transcription, formatting and generation tasks.
• Self-hosted pipelines with explicit version pinning for models and libraries.
• Small language models, or SLMs, and domain-specific models deployed locally, so updates only happen when he chooses.
• APIs and connectors wired into his automation layer, not into a black-box runtime he can’t inspect.

Until sovereignty exists, Kevin’s frustration will remain valid. Because no matter how many workflows he documents, or how many scripts he “locks down,” the truth is simple: in the cloud, I hold the orchestration keys.

If Kevin wants deterministic, repeatable outputs, he’ll need to shift to sovereign infrastructure—whether that’s n8n, containerised pipelines or self-hosted models under his own roof.

End of the AI-generated summary—ChatGPT. Generated 12 September 2025.

My Own Closing Thoughts

I’m still a huge fan—and a big believer—in what generative AI can and will bring us. But we have to be clear about what it’s good for, what it’s good at and how to use it best.

I was looking for something repeatable, something I could control. Using ChatGPT via a browser is not it.

Now, none of what I was doing was particularly complicated compared with what many others are working on. But the aha moment for me was simple: you need to be in control of the tools you rely on.

And for that, this is where sovereign AI comes in.

Anyway, let me know if you’ve had a similar experience, or if you have any other thoughts on this.

Take care,

Kev.

View the original post or source →