The AI landscape has evolved dramatically over the past three years, and we're now entering the era of agent harnesses. But here's something most developers don't realize: if you're using a closed harness system, especially one behind a proprietary API, you're essentially handing over control of your AI agent's most valuable asset—its memory.
What Are Agent Harnesses and Why They Matter
Agent harnesses are the scaffolding systems that enable AI models to interact with tools, data sources, and maintain context over time. Think of examples like Claude Code, Deep Agents, Pi, OpenCode, and many others that have emerged as the "best practice" for building sophisticated AI agents.
Some people believe that as AI models get better, they'll absorb more of this scaffolding functionality. But that's not what's happening. While some basic scaffolding from 2023 is no longer needed, it's being replaced by more sophisticated systems. Even when Claude Code's source was leaked, it revealed 512,000 lines of code—that's the harness at work.
The reality is simple: an agent, by definition, is an LLM interacting with tools and external data. There will always need to be a system orchestrating these interactions, even when capabilities like web search appear "built into" model APIs.
The Inseparable Link Between Harnesses and Memory
Here's the crucial insight: memory isn't a plugin you can just add to any system—it's fundamentally part of the harness itself. As AI researcher Sarah Wooders puts it, "Asking to plug memory into an agent harness is like asking to plug driving into a car."
The harness manages all forms of context:
- Short-term memory: Conversation messages, tool call results
- Long-term memory: Cross-session information that persists over time
- System instructions: How agent configurations are loaded and maintained
- State management: What survives when conversations are compressed, how interactions are stored
Since we're still in the early stages of understanding AI memory, there aren't yet standardized abstractions. This means memory systems are tightly coupled to their harnesses—you can't easily separate them or transfer memory between different systems.
The Lock-in Problem: Losing Control of Your Most Valuable Asset
When you use a closed harness system, you face several levels of problems:
Mildly Problematic
Using stateful APIs (like OpenAI's Responses API) means your state lives on their servers. Want to switch models while keeping your conversation history? You're out of luck.
Bad
Closed harness systems interact with memory in ways you can't see or understand. You might get some client-side artifacts, but their format and usage remain a black box, making them non-transferable.
Catastrophic
When the entire harness and long-term memory sit behind a proprietary API, you have zero ownership or visibility. You don't know how the memory works, and worse—you don't actually own it.
This is exactly what's happening with systems like Anthropic's Claude Managed Agents, which locks everything behind their platform. Even "open" systems like Codex generate encrypted compaction summaries that only work within the OpenAI ecosystem.
Why Memory Creates Powerful Lock-in
Model providers are heavily incentivized to control memory because it's what transforms a commodity AI model into a sticky, differentiated experience. Here's why memory matters so much:
- Personalization: Agents learn user preferences and adapt over time
- Continuous improvement: Each interaction makes the agent better for that specific user
- Competitive moats: Without memory, agents are easily replicable; with memory, you build proprietary user datasets
A personal example: Harrison Chase (the author of the original piece) had an email assistant that learned his preferences over months. When it was accidentally deleted, recreating it from the same template resulted in a dramatically worse experience—he had to reteach everything from scratch. That moment of frustration revealed just how valuable and sticky memory had become.
The Solution: Open Memory and Open Harnesses
The path forward is clear: memory needs to be open and owned by whoever is developing the AI experience. This means:
- Using open-source harness systems where you can see and modify how memory is handled
- Ensuring your agent's memory is stored in formats you control and understand
- Building systems where memory can be transferred between different harnesses or model providers
- Maintaining ownership of the proprietary datasets that make your agents unique
It's been relatively easy to switch between model providers because they're largely stateless—similar APIs, minor prompt adjustments. But as soon as state and memory enter the equation, switching becomes exponentially harder because that memory represents real value you can't afford to lose.
The Bottom Line
Agent harnesses aren't going anywhere—they're becoming more sophisticated and essential. Since memory is inextricably linked to harnesses, choosing a closed system means giving up control of your most valuable asset. As the AI agent ecosystem matures, owning your memory will be the difference between building a commodity experience and creating something truly differentiated.
The choice is yours: own your harness and your memory, or become locked into someone else's platform. Choose wisely.
This post is based on insights from Harrison Chase's analysis on the LangChain blog. As the creator of LangChain and LangGraph, Chase has been at the forefront of AI agent development and brings unique perspective to these emerging challenges.