I have been watching OpenAI add capability at a ridiculous pace, and I freaking love it.
The new features are useful, but what impresses me almost as much is how natural many of them feel. If you have spent enough time working inside these systems, you usually do not need a twenty-page manual explaining what a new capability is supposed to do. You see it, try it, and understand where it fits. That is good product design, and OpenAI has become very good at it.
Anthropic is doing impressive work too. Google is pushing hard. New models and new execution environments keep appearing. The competitive cycle is moving quickly enough that something extraordinary today can become ordinary six months later.
I want all of it.
Give me the strongest reasoning model. Give me the coding agent that can work for hours. Give me deep research, memory, browsers, voice, computer use, connectors, automation, multimodal reasoning, persistent execution, and whatever else these companies invent next. If somebody builds a capability that materially improves what I can accomplish, I want to use it.
That enthusiasm is exactly why I think people need to be careful.
The platforms are becoming so good that it is increasingly easy to hand them pieces of your operating system without realizing that is what you are doing. A conversation becomes a project. The project acquires memory. Memory becomes connected to files. Files connect to applications. Applications become tools an agent can operate. Automations begin running against all of it. Eventually the provider is no longer simply supplying intelligence. It sits in the middle of an increasingly large portion of how you work.
None of that requires bad intent. I do not think OpenAI is evil. I do not think Anthropic is evil. I do not need to imagine some executive team plotting an elaborate strategy to imprison my data.
The incentives are enough.
Every platform benefits when more of your work happens inside its boundaries. Every ecosystem becomes more valuable when your files, history, workflows, automations, agents, memory, permissions, and habits become connected to everything else it provides. That is normal business. The provider wants retention. You want capability. Most of the time those interests align very nicely.
The problem begins when convenience quietly turns into structural dependency.
The dependency sneaks up on you
Traditional vendor lock-in was easier to recognize. Maybe your application depended too heavily on one cloud provider. Maybe your database used proprietary features. Maybe moving several hundred terabytes somewhere else would be expensive and annoying. Those are serious problems, but at least everybody understood roughly what was being locked in.
AI changes the shape of the dependency because the valuable thing inside the platform is increasingly not just data or compute. It is context.
What happens when a platform does not merely store your files but begins to understand the relationships among them? What happens when years of working history accumulate in conversations, memories, projects, agent state, automations, connected applications, tool permissions, and proprietary context mechanisms? What happens when the system becomes useful partly because it has learned how your work fits together?
Now leaving is no longer just a data-migration problem.
A folder can be copied. A database can be exported. A virtual machine can be rebuilt. Those migrations may be unpleasant, but the objects are reasonably well understood.
Accumulated operational context is different. It may contain relationships, chronology, provenance, decisions, authority, semantic connections, working assumptions, agent procedures, unresolved questions, and tacit knowledge that were never represented independently of the platform that learned them.
That creates a new class of portability problem.
Cloud lock-in traps workloads. AI lock-in can trap context.
I think context may ultimately prove to be the more valuable asset.
Good platforms create a different kind of architectural risk
There is a strange paradox here. Bad technology creates relatively little long-term dependency because people are happy to leave it. Great technology creates much more dependency because staying feels rational.
That does not make great products dangerous in some moral sense. It means architects need to separate two things that naturally want to collapse together: capability and authority.
I want providers competing ferociously to give me capability. I want better models, better tools, better agents, better interfaces, lower prices, deeper context, stronger multimodal reasoning, and more reliable execution. What I do not want is for the provider supplying those capabilities to become the constitutional authority for the system consuming them.
OpenAI can reason. Anthropic can reason. Google can reason. Local models can reason. Some company none of us knows yet may eventually outperform all of them. Those systems can interpret information, generate software, search enormous bodies of material, classify evidence, infer relationships, operate tools, and propose actions.
That is capability.
Authority is different. Authority determines what an object is, where it came from, which version superseded another, who authorized a consequential action, what evidence supports a claim, what state is canonical, what may change that state, and how the system can reconstruct what happened later.
Those things should not exist only inside whichever provider happens to be smartest this quarter.
We built for this before I had the broader language for it
While developing this argument, I went back through my own Git history.
That was useful because human memory remains a remarkably unreliable storage architecture.
The underlying principle was already there.
In July 2026, while GhostMesh was still changing quickly, we defined a provider-neutral Tony Brain adapter contract. The immediate goal was fairly narrow: knowledge identity should remain separate from the transport used to reach it. A logical source should not become indistinguishable from whichever provider currently exposes it.
A few days later the architecture became considerably more explicit. GhostMesh's provider-neutral execution design treated Codex, OpenAI API agents, alternate providers, and deterministic workers as execution adapters behind a repository-owned contract.
The important thing was not simply that multiple providers could execute work. Plenty of systems can route between APIs. The important thing was that the provider did not own the operating contract. The task package, context package, authority model, acceptance criteria, execution states, evidence contract, budgets, and stop conditions remained outside the provider.
Codex could be extraordinarily useful without becoming structurally indispensable. Another model could eventually replace it without redefining what the work meant.
The provider performed the work. It did not define the work.
At the time, we were solving an operational engineering problem. I wanted GhostMesh to survive workstation loss, provider degradation, quota limits, product changes, account problems, and future provider replacement without forcing us to rebuild the governing system around whatever came next.
Looking backward, I think we were implementing a broader principle before I had settled on the language for it.
Capability can be rented aggressively. Authority should not be rented at all.
Probabilistic semantics. Deterministic authority.
That distinction eventually became one of the most important architectural ideas in everything I am building:
Probabilistic semantics. Deterministic authority.
Models are probabilistic systems. That is not a defect we need to eliminate. It is one of the reasons they are useful. They can reason through ambiguity, recognize relationships, summarize incomplete evidence, generate alternatives, classify uncertain situations, and work productively in spaces where deterministic software becomes brittle or absurdly complicated.
Use that capability aggressively.
But the question "What does this probably mean?" is fundamentally different from the question "What has authority?"
Suppose a model concludes that two records appear to describe the same underlying event. That may be useful evidence. It does not automatically make those records identical.
Suppose an agent determines that a proposed change probably satisfies the owner's intent. That is valuable reasoning. It does not mean the agent silently acquires authority to promote the change into Production.
Suppose a model reconstructs a decade of history and infers why a decision was probably made. Excellent. That inference can help humans understand the record, but the original evidence, chronology, and provenance still matter.
The model can interpret history without becoming history.
This separation matters more as models become capable enough to act, because powerful reasoning plus weak authority boundaries can move from interesting error to consequential error very quickly.
Own the things you cannot cheaply reconstruct
Sovereignty does not mean owning every machine. I have no desire to rebuild OpenAI in my basement. The electrical service alone would probably create an interesting conversation at home.
Nor does sovereignty mean refusing managed services, SaaS, cloud infrastructure, proprietary software, or frontier models. That would confuse independence with self-inflicted inconvenience.
The practical question is simpler: which parts of the system would be catastrophically expensive to reconstruct if a provider disappeared?
Those are the things you need to protect.
Identity, provenance, lineage, authority, policies, canonical artifacts, historical state, decisions, relationships, execution receipts, and knowledge structure all fall into that category. So does the ability to reconstruct what happened and why.
Those are durable assets because they represent accumulated meaning.
The infrastructure underneath them should be much more negotiable. Models should be negotiable. Inference providers should be negotiable. Vector databases should be negotiable. Cloud providers should be negotiable. Agent frameworks, runners, indexing engines, and interfaces should all eventually be replaceable without forcing the organization to rediscover its own history.
Replacement does not need to be free. Engineering has never worked that way.
It does need to be bounded.
Vendor agnostic is usually a slogan
Technology organizations love writing "vendor agnostic" on architecture slides. Then somebody inspects the implementation and discovers that identity depends on one vendor, workflows depend on another, the memory model exists inside a proprietary product, agents assume one tool protocol, semantic indexes use provider-native identifiers, and the audit history lives in service logs with limited retention.
Somewhere in the architecture diagram there is usually an abstraction layer, so everyone feels sufficiently enterprise for the afternoon.
That is not sovereignty.
Real portability has to survive provider removal. Hiding APIs behind interfaces is useful, but insufficient. The meaning of the system must also exist independently of those APIs.
Provider-specific objects should map into owner-controlled identities. Provider-specific execution should map into owner-controlled lifecycle states. Provider-native evidence should map into durable provenance. Provider memory can be incredibly useful, but it should be treated as a projection or convenience layer rather than the only place where institutional truth lives.
Adapters belong at the edge.
Authority belongs at the core.
Portability is not an export button
This is another word technology companies have managed to weaken through overuse.
Being able to download your data is useful. It is not the same thing as being able to continue operating.
Suppose a provider gives you ten thousand JSON files on the way out. You possess the bytes, which is certainly better than not possessing them. But do you know which records are canonical? Which objects superseded earlier versions? Which relationships were model-inferred and which were explicitly authorized? Which decision governed a particular implementation? Which evidence supported a claim at the time it was published? Which policy was active? Which execution succeeded, which failed, and which was rejected before mutation?
If the answer is no, you do not have a portable system.
You have an archaeological site.
The real objective is not merely exportability. It is reconstructability.
A sovereign system should preserve enough identity, history, provenance, relationships, authority, and state that another implementation can rebuild the important operating context without asking the departing provider to explain what everything meant.
That is a considerably higher standard than "Download your data."
It is also much closer to what continuity actually requires.
The platforms themselves prove why this architecture is necessary
None of this requires assuming bad faith from providers. Their normal engineering behavior makes the case perfectly well.
Models change. Interfaces change. APIs evolve. Features get deprecated. Recommended architectures are replaced. Products are consolidated. Capability boundaries move.
That is healthy technology evolution.
OpenAI documents model and API deprecations and provides migration paths. Anthropic documents model lifecycle and retirement in the same way. When a model reaches retirement, applications need to move. That is not evidence that either company is unreliable. It is evidence that designing around permanent provider interfaces is a category error.
Even more interestingly, the providers increasingly describe the engineering challenge as something much larger than model intelligence.
OpenAI's own agent-first engineering work emphasizes repositories, tools, environment design, feedback loops, context, validation, and making the surrounding system legible to agents. Anthropic's context-engineering guidance makes a similar point from another direction by treating instructions, tools, external data, history, and working state as deliberate engineering inputs.
In other words, the model companies themselves are telling us that the model is only one part of the system.
I agree completely.
My conclusion is simply that the rest of that system should remain reconstructable without them.
The exit test
Every serious AI architecture should eventually have an exit test.
Pick a major dependency and imagine that it disappears tomorrow. OpenAI. Anthropic. Google. GitHub. Cloudflare. Your vector store. Your identity provider.
Something will break because dependencies are real. That is normal. The useful question is not whether losing a provider creates disruption. The useful question is what kind of disruption the architecture creates.
Does the situation become: we need to qualify another provider, test compatibility, redirect workloads, and restore service?
Or does it become: we no longer know how our own system works because too much meaning existed only inside the platform that disappeared?
Did you create a migration problem, or did you lose the ability to understand your own system?
The first is an engineering problem.
The second is a sovereignty failure.
Switching should eventually become boring
This is the operational objective.
Not magical portability. Not zero migration cost. Not some absurd fantasy that every provider is identical.
Boring replacement.
Select an alternative. Run compatibility tests. Evaluate capability. Validate security and economics. Replay representative workloads. Compare outputs and evidence. Move a bounded percentage of execution. Observe what changes. Expand gradually. Retire the predecessor when appropriate.
The provider changes, but the task contract survives. Knowledge identities survive. Authority rules survive. Historical evidence survives. The surrounding operating model survives.
That is engineering.
If changing models requires rebuilding your memory, identity, workflows, history, policies, and knowledge relationships, you did not merely integrate a provider. You allowed it to become part of your constitution.
Sovereignty is economic leverage
There is also a less philosophical reason to care about any of this.
Money.
If you cannot leave a provider, the provider has leverage whether it chooses to exercise that leverage or not. Optionality changes the economics of the relationship.
If appropriate workloads can move among frontier providers, smaller models, deterministic machinery, local execution, or future alternatives, then provider pricing becomes one input into an engineering decision. If everything is tightly fused to one platform, price changes become architectural events.
That is a lousy negotiating position.
Regulators have been dealing with the more conventional version of this problem for years. The European Union's Data Act explicitly addresses barriers to switching between data-processing services and interoperability. NIST was discussing cloud portability and vendor lock-in long before generative AI arrived.
The underlying problem is not new.
AI simply makes the asset being locked in more valuable.
We used to worry primarily about where the application ran and where the data lived. Now we also have to worry about where the system's accumulated understanding of that data lives.
Sovereignty is not isolation
There is a dumb version of this argument where everybody responds by self-hosting everything because corporations cannot be trusted.
That is not what I am proposing.
Managed platforms are useful precisely because somebody else absorbs enormous amounts of engineering complexity. I like that arrangement when the incentives make sense.
Use proprietary models. Use hosted databases. Use SaaS. Use cloud infrastructure. Use managed identity. Use somebody else's GPU fleet. Use whatever provides the best capability at an acceptable cost and risk.
The objective is not zero dependency.
The objective is controlled dependency.
I am comfortable depending on another company for a capability. I am much less comfortable depending on that company for my ability to understand and reconstruct my own system.
Those are fundamentally different dependencies.
Build above the providers
The architectural answer is to move the durable control point upward.
OpenAI sits below it. Anthropic sits below it. Google sits below it. Local models sit below it. Cloud infrastructure, execution environments, databases, indexing engines, and storage systems sit below it too.
They compete to provide capability.
Above them sits an owner-controlled plane containing identity, provenance, lineage, authority, policy, evidence, historical state, and reconstruction.
Providers can participate in that system. They can make it dramatically better. They can perform enormous amounts of work inside it.
They should not define what the system is.
This is why GhostMesh increasingly looks less like an AI product to me and more like a control plane for interchangeable intelligence. The intelligence matters enormously, but intelligence alone does not establish authority.
The owner does.
The paradox
The funny thing is that I am probably more enthusiastic about these platforms today than I have ever been.
The capabilities are getting extraordinary. The interfaces are improving. The systems are becoming more useful, more intuitive, and more deeply integrated into real work. I want that trend to accelerate.
But precisely because these platforms are becoming so good, the architecture around them has to become more disciplined.
Weak platforms constantly remind you that you need an exit.
Great platforms make you forget.
That is why the exit has to exist before you desperately need it.
Use the hell out of it
I want agents doing work humans should not waste their lives doing. I want models reasoning across enormous bodies of information. I want automated engineering, research, validation, publication, recovery, and operations.
I want the best system OpenAI can build. I want the best system Anthropic can build. I want whatever Google produces. I want whoever beats all three of them next.
I am not interested in technological purity.
I am interested in leverage.
That means aggressively consuming capability while keeping the authority boundary unmistakable. Use every useful thing these companies invent. Give them workloads. Give them problems. Let them compete for the right to do more.
Just do not accidentally hand them ownership of the system around the work.
Use everything. Own the system. Keep the exit executable.
Reader Trust Stack
Evidence, claims, lineage, and reconstruction
Claims
SOV-01 · AI integration can create context dependency.
Posture: architectural inference
Support: SOV-E04, SOV-E10
Boundary: The sources do not measure cognitive lock-in or establish that every integration creates it.
SOV-02 · Provider interfaces are temporal.
Posture: externally verifiable fact
Support: SOV-E01, SOV-E02
Boundary: A documented lifecycle does not establish provider malice, unreliability, or a particular future retirement date.
SOV-03 · Context is engineered system state.
Posture: externally corroborated engineering observation
Support: SOV-E03, SOV-E04
Boundary: This does not establish that all context is portable or that the model is unimportant.
SOV-04 · Authority can remain independent of capability.
Posture: owner architectural doctrine supported by implemented historical design
Support: SOV-E07, SOV-E08, SOV-E09, SOV-E10
Boundary: Historical design is evidence of the chosen architecture, not proof of universal runtime enforcement or zero migration cost.
SOV-05 · GhostMesh explicitly designed for provider replacement by July 2026.
Posture: primary-source historical fact
Support: SOV-E07, SOV-E08, SOV-E09
Boundary: The July 25 merge records acceptance while the ADR header says Proposed; this Work does not resolve that metadata inconsistency.
SOV-06 · Reconstructability is stronger than exportability.
Posture: systems inference
Support: SOV-E04, SOV-E06, SOV-E10
Boundary: No cited standard certifies this Work’s reconstructability test or guarantees complete context recovery.
SOV-07 · Portability creates resilience and economic optionality.
Posture: bounded systems/economic inference
Support: SOV-E05, SOV-E06, SOV-E10
Boundary: No universal savings, negotiating advantage, effortless migration, legal entitlement for every service, or quantified resilience gain is claimed.
SOV-08 · Cognitive lock-in extends traditional vendor lock-in.
Posture: original synthesis of this Work
Support: SOV-E06, SOV-E10
Boundary: Original architectural synthesis, not a settled empirical law, provider endorsement, or externally proven taxonomy.
Evidence plane
SOV-E01 · OpenAI · Deprecations
Supports: OpenAI documents model and API retirement, notice periods, shutdown dates and migration replacements. Interfaces have lifecycles.
Does not establish: Does not establish malice, inevitable loss of context, identical replacement behavior, or a universal migration cost.
Source locator · retrieved 2026-10-04
SOV-E02 · Anthropic · Model deprecations
Supports: Anthropic distinguishes active, legacy, deprecated and retired models, publishes retirement dates and recommends replacements. Retired API models stop serving requests.
Does not establish: Does not establish provider unreliability, hostile intent, or that an API migration necessarily loses operating context.
Source locator · retrieved 2026-10-04
SOV-E03 · OpenAI · Harness engineering: leveraging Codex in an agent-first world
Supports: The first-party engineering report describes repository knowledge, environment design, tools, validation and feedback loops as deliberate parts of an agent-operated engineering system.
Does not establish: Does not prove universal productivity gains, endorse this sovereignty doctrine, or demonstrate that every context dependency is reconstructable.
Source locator · retrieved 2026-10-04
SOV-E04 · Anthropic · Effective context engineering for AI agents
Supports: Context engineering curates instructions, tools, external information and evolving interaction state. It corroborates context as an engineering concern; dependency and reconstructability remain this Work’s inferences.
Does not establish: Does not establish cognitive lock-in as an empirical law, confer authority on model memory, or validate the complete owner-control architecture.
Source locator · retrieved 2026-10-04
SOV-E05 · European Commission · Data Act explained — Chapters VI and VIII
Supports: The Commission describes switching barriers and interoperability requirements for in-scope data-processing services, including cloud and edge services. This is regulatory prior art for switching and optionality.
Does not establish: Does not establish that every AI product, jurisdiction, deployment or contract is covered; does not guarantee semantic reconstruction or zero total engineering cost. Provider intellectual-property/trade-secret boundaries and service-specific duties matter.
Source locator · retrieved 2026-10-04
SOV-E06 · NIST · Cloud Computing Synopsis and Recommendations — NIST SP 800-146
Supports: Sections 8.3.3–8.3.4 address workload portability, standardized interfaces/data formats, vendor-specific obstacles and provider interoperability. These establish cloud prior art, not the new AI synthesis.
Does not establish: Does not address today’s frontier-model memory, validate cognitive lock-in, guarantee provider equivalence, or quantify this Work’s economic benefits.
Source locator · retrieved 2026-10-04
SOV-E07 · Tony Malott / GhostMesh · Provider-neutral Tony Brain adapter contract
Supports: The July 21 commit adds the adapter contract, schemas, validators and synthetic tests separating logical source identity from provider transport.
Does not establish: The initial adapter is synthetic and has no live ingestion/runtime integration. It does not prove production failover or all-provider portability.
https://github.com/pinklon/shareplane-control-tower/commit/bfd6249cb02b367ee392453037fb19a7f5531de0
Repository access required for original locator; public-safe verification receipt is included. Public-safe record · retrieved 2026-10-04
SOV-E08 · Tony Malott / GhostMesh · Provider-neutral cloud execution architecture
Supports: The July 25 commit records acceptance of ADR 0009 and places replaceable executors behind repository-owned task, context, authority and evidence contracts.
Does not establish: Architecture acceptance is distinct from deployed capability or a completed exit exercise. The ADR file’s Proposed header is not silently corrected.
https://github.com/pinklon/shareplane-control-tower/commit/83eb65ba11b7654dd2b652cddcde00fc886a0cc3
Repository access required for original locator; public-safe verification receipt is included. Public-safe record · retrieved 2026-10-04
SOV-E09 · Tony Malott / GhostMesh · ADR 0009: Provider-Neutral Cloud Execution Fabric
Supports: The pinned decision puts Codex, OpenAI API agents, alternate providers and deterministic scripts behind one repository-owned versioned execution contract. Provider-specific behavior remains at the adapter edge.
Does not establish: A design record does not establish that every intended adapter, failover path or exit test was implemented. Header/acceptance metadata disagree.
https://github.com/pinklon/shareplane-control-tower/blob/83eb65ba11b7654dd2b652cddcde00fc886a0cc3/docs/adr/0009-provider-neutral-cloud-execution-fabric.md
Private repository; public-safe verification receipt supplied. Public-safe record · retrieved 2026-10-04
SOV-E10 · Tony Malott · Use Everything. Own the System. — semantic lock
Supports: Owner authority for the exact manuscript, original synthesis, doctrine, six teaching figures, graph declarations and protected Development scope.
Does not establish: Owner acceptance of an argument is not external empirical verification. It grants no merge or Production authority.
https://github.com/pinklon/shareplane-platform/issues/1304
Repository access may be required; canonical manuscript and public-safe semantic metadata are included in this package. Public-safe record · retrieved 2026-10-04
Historical lineage
This Work binds the July 21 provider-neutral Tony Brain adapter contract and the July 25 Provider-Neutral Cloud Execution Fabric to exact Git identities. The July 25 acceptance commit and ADR header disagree on status; the discrepancy is preserved rather than silently normalized.
bfd6249cb02b367ee392453037fb19a7f5531de083eb65ba11b7654dd2b652cddcde00fc886a0cc3
Provenance and boundary
Owner-approved architectural thesis; locked manuscript and historical claims under SharePlane Platform Issue #1304.
AI assistance: Developed with AI assistance under Tony Malott’s direction; repository implementation, deterministic figures and validation by Codex. Tony owns the thesis and semantic authority.
Public-safe boundary: Public-safe narrative and bounded historical design summaries only. No private repository file contents, credentials, internal operational topology or raw execution paths are included.
Portable Work
The publication package carries the manuscript, metadata, evidence ledger, claim ledger, relationship graph, integrity record, reader presentation, and all six deterministic teaching figures.
Download public-safe Work package