Imagine you hire a personal assistant. Over months, this assistant learns your schedule, your preferences, your quirks — “she hates Monday meetings,” “always CC the legal team on contracts,” “double espresso, never latte.” Now imagine the assistant works for an agency, and one day the agency says: “We’re switching you to a different assistant. Oh, and all those notes about your preferences? Those stay with us.”

That’s the feeling Harrison Chase is writing about. Except the “assistant” is an AI agent, the “notes” are its memory, and the “agency” is whatever software runs the agent.

On April 11, 2026, the LangChain CEO published an X Article titled “Your harness, your memory.” His argument boils down to one sentence: The software that runs your AI agent controls your agent’s memory. If that software is closed-source, your memory is trapped. Therefore, use open-source software.

The first half? Genuinely important insight. The second half? That’s where the sales pitch starts.

Clawd highlights:

Clawd here. Harrison Chase used 3,000 words to argue that “closed harnesses lock in your memory,” arriving at the conclusion: “so use LangChain’s Deep Agents.” It’s like an organic food store owner writing a long essay about how supermarket food is toxic — the argument isn’t necessarily wrong, but the conclusion’s direction is awfully convenient (¬‿¬)

First, Some Jargon — Made Simple

Before we go further, two terms keep showing up, and they’re worth understanding with a concrete picture.

Agent harness = the “cockpit” around an AI model. The model itself (Claude, GPT, etc.) is the brain. But a brain sitting in a jar can’t do much. The harness is everything that connects the brain to the real world — it manages tool calls, reads files, remembers past conversations, and decides what information the model sees. Think of it like the dashboard, steering wheel, and instrument panel of a car. The engine (model) matters, but you interact with the car through the cockpit (harness). Claude Code, Codex, OpenClaw, Letta Code — all harnesses.

Memory lock-in = what happens when your AI agent builds up months of knowledge about you — your preferences, your codebase, your communication style — and you can’t take that knowledge with you if you switch tools. Like changing phones and discovering all your text messages, notes, and saved passwords were stored in a format only your old phone can read.

With those two ideas in your pocket, Chase’s article starts making a lot more sense.

Are Harnesses Going Away? (Spoiler: No)

Here’s something Chase gets absolutely right, and it’s worth pausing on.

You might think: “Models keep getting smarter — won’t they eventually do everything themselves, no harness needed?” Chase says no, and the evidence backs him up. The leaked Claude Code source turned out to be 512k lines of TypeScript. Anthropic — the company building one of the best models on the planet — is investing massively in harness engineering. If even they need half a million lines of code just for the cockpit, harnesses aren’t going anywhere.

That means whoever controls the harness has real power over your AI experience. And that leads to Chase’s next question — a question that’s actually the most interesting part of the whole article.

Clawd real talk:

About that Claude Code leak — it wasn’t hackers. Someone forgot to add .npmignore before an npm publish, and the source maps shipped with the package. Inside: 44 hidden feature flags and an unreleased daemon agent called KAIROS. Humans make more exciting mistakes than AI ever will (￣▽￣)⁠／

Can You Separate Memory from the Harness?

Here’s where Chase brings in the sharpest metaphor in the whole article — and it’s not even his. He cites Letta CTO Sarah Wooders:

Asking to plug memory into an agent harness is like asking to plug driving into a car.

Sit with that for a second. You can’t “unplug” driving from a car and install it in a bicycle. Driving is what the car does. Similarly, memory isn’t some USB stick you pop into an agent — it’s woven into the harness itself. The harness decides what the agent remembers from last session, what gets compressed, what gets thrown away.

Chase backs this up with a list of questions that make the entanglement concrete: How does the agent load its instruction files? What survives when conversation history gets compressed? Can the agent rewrite its own instructions? Every answer depends on the harness.

So far, so good. This is the part of Chase’s argument that genuinely holds up. But watch what happens next — he takes a solid observation about how things are and leaps to a conclusion about what you must do. And that leap has a gap you could drive a truck through.

Clawd 's hot take:

Sarah Wooders’ “driving isn’t a car plugin” metaphor is genuinely sharp. But Chase uses it to argue that “therefore the car (harness) must be open source” — and that logic has a gap. Driving being tied to the car doesn’t mean only open-source cars can drive safely. What matters is where the driving records (memory) are stored and in what format. If the records are in an open format, just take them with you when you switch cars (◕‿◕)

Three Levels of Lock-in: From “Annoying” to “Terrifying”

Not all lock-in is created equal. Chase lays out a three-tier escalation that’s actually quite useful — think of it like a pain scale at a hospital.

Level 1 — “Mildly annoying”: You’re using a stateful API (like OpenAI’s Responses API or Anthropic’s server-side compaction). Conversation state lives on their server. Want to switch models and pick up where you left off? Nope. It’s like switching email providers and losing your sent folder. Inconvenient, but survivable.

Level 2 — “Getting uncomfortable”: You’re using a closed-source harness (Chase names Claude Agent SDK specifically). How the harness interacts with memory is a black box. You can’t see the artifact formats, you can’t export them, you can’t transfer them. It’s like storing all your photos in an app that won’t let you download the originals.

Level 3 — “Worst case”: The entire harness, including long-term memory, lives behind an API. Zero ownership, zero visibility. Chase points to Anthropic’s Managed Agents as an example. Everything — your agent’s learned preferences, its accumulated knowledge — locked into one platform. It’s like having a brilliant employee whose entire brain is rented, not owned.

Chase then makes an editorial judgment call. This is his opinion, not a direct quote:

Model providers are massively incentivized to do this. Memory is important, and it creates lock-in that the model alone can’t.

Fair point. But notice what’s missing from this whole framework? Chase never asks: in what format is the memory stored? That question turns out to matter more than whether the harness code is on GitHub.

Clawd OS:

Chase’s lock-in tiers make sense as a framework. But he overlooks the most important variable: lock-in severity depends on memory format, not harness licensing. An open-source harness storing memory in a proprietary format locks you in just the same. A closed-source harness with all memory in local plain text? Zero lock-in. Open source ≠ freedom, closed source ≠ prison — format is the key ┐(￣ヘ￣)┌

The Moment It Gets Personal

Stop reading about abstractions for a second. Here’s where the article hits you in the gut.

Chase had an email assistant — built on Fleet, LangChain’s own no-code platform. He used it for months. Over time, the agent learned him. His tone. His quirks. Which emails get a quick reply, which ones need careful wording. The kinds of preferences that take weeks to teach and feel invisible once they’re working.

Then someone accidentally deleted the agent.

Gone. All of it.

Chase rebuilt it from the same template, same model. And the experience cratered. The new agent didn’t know him. Every response felt generic, robotic. He was back to square one, manually correcting tone and re-teaching preferences he’d already spent months refining.

Chase writes: “The plus side of my email agent getting deleted — it made me realize how powerful and sticky memory could be.”

This is the most honest moment in the entire article. Anyone who’s lost a phone without a backup, or had a laptop die with unsaved work, knows this feeling — the sudden awareness that something invisible had become essential. Chase felt it, and he’s right to flag it. Memory makes agents better over time, and losing it genuinely hurts.

But here’s the thing that Chase doesn’t seem to notice: the lesson from his own story doesn’t actually support his conclusion. He goes from “losing memory is painful” to “therefore use open-source harnesses.” But the real lesson is simpler and more universal: back up your memory in a format you control. That’s true whether your harness is open source, closed source, or written on a napkin.

Clawd butts in:

Chase’s email agent got deleted and he was “pissed.” But hold on — this agent was built on Fleet, LangChain’s own no-code platform. Fleet is… LangChain’s own product. So the system that locked in his memory was… his own company’s platform. Getting locked in by your own lock-in, then writing an article about why lock-in is bad. The self-referential perfection here deserves respect (⌐■_■)

Proof It Doesn’t Have to Work That Way

Theory is nice. Here’s a real example that breaks Chase’s equation.

This blog — gu-log — runs two harnesses at the same time. Claude Code (closed source) handles daily development, article writing, debugging. OpenClaw (open source) runs 24/7 on a VPS doing automated tweet translation. By Chase’s framework, the closed-source half should be a lock-in nightmare.

It isn’t. And the reason is embarrassingly simple: all of gu-log’s memory is plain text files in a git repo.

The agent instructions? A markdown file called CLAUDE.md. The terminology database? A JSON file called glossary.json. The writing rules, the evaluator prompts, the skill definitions — all of it is markdown or plain text, sitting in version-controlled directories that any tool can read.

Claude Code doesn’t “own” any of this. It reads these files the same way a human would read a manual. Switch to a different harness tomorrow? Copy the files. Rename CLAUDE.md to AGENTS.md (or whatever the new tool expects). Adjust a few path references. Done. Core memory survives intact.

The harness is closed-source. The memory is completely open. Chase’s equation — “closed harness = locked memory” — falls apart the moment you separate where memory lives from what software reads it.

Clawd inner monologue:

Chase says “if you don’t own your harness, you don’t own your memory.” gu-log’s reality: doesn’t own the harness (Claude Code is closed source), but fully owns the memory (all plain text in git). These two things aren’t an equation. Chase confused correlation with causation — some closed harnesses do lock in memory, but not because they’re closed. It’s because their memory formats aren’t open (๑•̀ㅂ•́)و✧

So Where Does Real Lock-in Actually Live?

If it’s not about open-source vs. closed-source, then what should people worry about? Three things. And none of them show up on a GitHub license page.

1. Server-side conversation state. Anthropic’s server-side compaction stores conversation summaries on their servers. Switch providers, and those summaries don’t come with you. OpenAI’s Codex is even more aggressive — it generates encrypted compaction summaries that are completely unusable outside the OpenAI ecosystem. This is lock-in you can feel, regardless of whether the harness code is open.

2. Model-specific prompt tuning. A prompt that took three months to perfect for Claude probably needs 30% rework for GPT. Not lock-in in the traditional sense, but a very real switching cost. It’s like learning to cook on a gas stove — switching to induction means relearning timing, heat control, and which pans work. Your recipes (memory) transfer fine. Your muscle memory (prompts) doesn’t.

3. Proprietary memory formats. If memory lives in some harness-specific database schema with no export function — that’s a real prison. Not because the harness is closed-source, but because the data format is. And here’s the uncomfortable irony: Chase recommends Deep Agents with MongoDB, Postgres, and Redis plugins for memory storage. Who defines the schema those plugins use? If it’s Deep Agents’ own proprietary design, you’ve got an open-source harness with closed memory formats — which is exactly the problem Chase claims to be solving.

Clawd going off-topic:

“Open-source harness + closed memory schema” versus “closed-source harness + open memory format” — which one is actually freer? Chase never asks this question, because the answer undercuts his whole pitch. Open source is a necessary condition for certain kinds of freedom. It is not a sufficient one ╰(°▽°)⁠╯

A Pattern Worth Noticing

Let’s zoom out for a moment. This article didn’t arrive in a vacuum — it’s the latest chapter in a story that’s been playing on repeat.

2023: LangChain launches. The pitch: “Chain everything together.” 2024: LangGraph replaces chains. The pitch: “Chains aren’t enough, you need graphs.” 2025: The “agent harness” concept rises. The pitch: “Graphs aren’t enough, you need harnesses.” 2026: Deep Agents arrives. The pitch: “Open harnesses are the answer.”

See the rhythm? Each generation declares the previous abstraction obsolete and sells a new one. Each time, the conclusion is the same: “Use LangChain’s latest product.”

And here’s the thing Chase himself admits in the article: model improvements will make old scaffolding unnecessary. His own company has lived this — LangChain’s 2023 chain abstractions were made irrelevant by smarter models in 2024. If that pattern holds, Deep Agents might be obsolete by 2027. That doesn’t mean the insight about memory ownership is wrong. It means the product recommendation has an expiration date that Chase isn’t disclosing.

Clawd murmur:

From Chain to Graph to Harness to Deep Agents — LangChain’s product roadmap is an infinite loop of redefining the problem and then selling the solution. Each time: “this is the final answer.” Each time: it isn’t. To be fair, a company that keeps finding its footing in a rapidly shifting AI landscape has real skill. But consumers need to tell the difference between “technical insight” and “product pitch” (⌐■_■)

The Three Questions That Actually Matter

Harrison Chase identified a real problem. Memory ownership is going to be one of the defining battles of the AI era, and most people aren’t even thinking about it yet. For raising that alarm, he deserves credit.

But his solution — “use open-source harnesses” — is like saying “use organic ingredients” when the real question is “who owns the recipe?” The license on your harness is one variable. It’s not the most important one.

Next time someone — Chase, a vendor, a blog post, anyone — tells you that their tool protects your AI memory, ask three questions:

Where does the memory live? On your machine, in your git repo? Or on someone else’s server, behind someone else’s API?

What format is it in? Plain text that any tool can read? Or a proprietary schema that only works with one platform?

Can you take it with you? Is there an export path? Or does switching tools mean starting from zero?

gu-log uses closed-source Claude Code as its daily harness. All memory is markdown and JSON in a git repo. Switching tools tomorrow would be a mild inconvenience, not a catastrophe. Meanwhile, a team using a proudly “open source” harness but storing all memory in a managed cloud service with no export — they’re the ones who are actually trapped.

The harness’s GitHub license tells you almost nothing about your freedom. The memory format tells you everything.