Stop Renting Your AI. Own the Stack.
If your agent infrastructure relies on a single vendor’s model, memory store, and tool chain, you don’t own your deployment. You’re renting it — and the landlord can change the terms any time.
I’ve watched this happen twice in six months. A model provider changed rate limits mid-quarter with 72 hours notice. A harness vendor deprecated a plugin format that half our integrations depended on. Both times, teams that owned their stack pivoted in hours. Teams that rented theirs spent weeks rebuilding.
The model is not the agent. The agent is not the product. The stack that surrounds the model determines whether your deployment succeeds or fails. If that stack is owned by a vendor, your deployment is a rental. If it’s owned by you, it’s an asset.
The Four Layers of Lock-In
Most agent products are designed to lock you in at every layer:
| Layer | How vendors lock you | The switching cost |
|---|---|---|
| Model | Proprietary fine-tuning, prompt format dependence | Rebuild every prompt and chain |
| Memory | Proprietary context stores that don’t export | Lose all accumulated context |
| Tooling | Platform-specific plugins that don’t transfer | Rebuild every integration |
| Harness | Proprietary agent runtime | No ability to inspect, modify, or fork |
Andrew Ng put it directly at LangChain Interrupt this June: “Vendor lock-in is a critical concern. You need to preserve optionality.” That’s survival advice.
Memory Lock-In Is the Deepest Cut
Nate Jones’s Open Brain project frames it precisely: “Every time you open a new chat window, your AI starts from zero. Every tool switch costs you minutes of re-explaining context that should already be there.”
The deepest lock-in is not the model — it is memory. Claude has its memory. Codex has its session context. Gemini has its own. None share. The switching cost isn’t retraining prompts — it’s rebuilding the entire context of your relationship with the tool.
Memory portability is the strategic layer. Separate raw data from embeddings. Use a standard database backing — Postgres, a vector store on your infrastructure. Make context portable across model providers. See our glossary for what this architecture looks like.
Two Harnesses, One Lesson
Two events this spring exposed how fast the ground shifts.
In March, Anthropic accidentally shipped a sourcemap file in an npm update — 512,000 lines of TypeScript, 44 feature flags, 20+ unreleased features. The leak revealed KAIROS (always-on autonomous mode), ULTRAPLAN (30-minute remote planning), and Coordinator Mode. A clean-room Python port hit 75,000+ GitHub stars overnight.
OpenAI released Codex CLI under Apache 2.0 from day one. 60,000+ stars. Full agent loop documented and forkable. You can read it. You can replace it.
Different philosophies, same core primitives. What matters is whether the harness is replaceable. If your stack is a black box, you cannot inspect, modify, or migrate it. If it is open, you own your switching power.
What Owning the Stack Looks Like
| Layer | Owned approach | Rental alternative |
|---|---|---|
| Inference | Self-hosted + multi-provider routing | Single-provider API dependency |
| Memory | PostgreSQL + vector store on your infra | Proprietary context store, no export |
| Tooling | Open skills, MCP servers | Platform-specific plugins |
| Harness | Open-source agent loop | Proprietary runtime, no fork path |
This approach prevents lock-in, enables vendor pivots, and keeps memory portable. Garry Tan’s philosophy applies: “thin harness, fat skills.”
The Working Environment Is the Accountability Layer
An agent cannot own outcomes. It has no legal standing, no operational accountability, no ability to bear risk. The environment must be owned and controlled by the client:
- Runs on your hardware or dedicated tenancy
- Uses your data, in your jurisdiction
- Operates within permissions you define
- Blast radius bounded by your access controls
When you own the environment, you own the risk. When a vendor owns the environment, you own the risk but not the controls. That asymmetry is unacceptable for any production deployment.
The Bottom Line
Stack ownership is not a preference. It’s a deployment guarantee. An agent you can replace is an agent you can improve. An agent you’re locked into is an agent you’re stuck with.
The bottlenecks shifted from “can the model do it” to “can the harness, environment, and governance support it.” That shift rewards ownership over rental, portability over convenience, and infrastructure over subscriptions.
Own your stack. Or someone else will own your deployment.
The Series
This is the final piece in a four-part series on AI agent deployment.
- Part 1: Beyond the Chatbot — What actually counts as an AI agent.
- Part 2: The 3% Problem — Why 86% of enterprise agent pilots fail.
- Part 3: Which Species for Which Job? — Mapping architectures to real work.
- Part 4: Stop Renting Your AI. Own the Stack. — You are here.
We build Automata — autonomous AI agents for invoicing, scheduling, procurement, and customer resolution. Self-hosted on Jamaican infrastructure. Every deployment starts with a conversation about your stack.