AI Agents & Agentic Engineering
  • Context Engineering
  • Building AI Agents
  • Agentic Engineering Best Practices
  • Auto-Research and Self-Improving Agents
  • Self-Maintaining Agents
  • Scaling Long-Running Autonomous Coding
  • Data Agents
  • Agent Memory and Harness Ownership
LLM Internals & Training
  • Reinforcement Learning for LLMs
  • Cursor Composer 2
  • Training-Free GRPO
  • Prompt Repetition for Non-Reasoning LLMs
  • LLM Quantization
  • LLM Knowledge Bases
AI Safety & Security
  • Constitutional Classifiers
  • Project Glasswing
Graphics & Low-Level Programming
  • Shaders and GPU Programming
Personal Development & Mindset
  • Deep Focus and Productivity
  • Identity and Life Design
  • Self-Competition and Entrepreneurship

Agent Memory and Harness Ownership

Agent harnesses (the scaffolding systems around LLMs that manage tools, context, and orchestration) are not temporary. They are the permanent infrastructure of agentic systems. Memory is inseparable from the harness, and using closed or proprietary harnesses means yielding control of your agent's memory to a third party.

Source: Harrison Chase (@hwchase17)

Harnesses Are Permanent

There is a recurring expectation that models will absorb scaffolding over time, making harnesses unnecessary. This has not happened. What changes is which scaffolding is needed: the chains and flows of 2023 gave way to agent harnesses in 2025, but the amount of code around the model has not decreased. When Claude Code's source was leaked, it contained 512K lines of code. That code is the harness.

Even features that appear built into model APIs (like web search) are not part of the model. They are lightweight harnesses behind the API that orchestrate the model with external tools via tool calling.

Examples of current agent harnesses: Claude Code, Deep Agents (LangChain), Pi/OpenClaw, OpenCode, Codex, Letta Code.

Memory Is the Harness

Sarah Wooders (CTO of Letta) argued that "asking to plug memory into an agent harness is like asking to plug driving into a car." Memory is a form of context, and managing context is the core responsibility of the harness.

The harness controls:

  • How system instructions and skill metadata are loaded into context
  • What survives compaction and what is lost
  • Whether interactions are stored and made queryable
  • How the agent modifies its own instructions
  • How filesystem and working directory information is exposed

Short-term memory (conversation messages, tool results) and long-term memory (cross-session knowledge) are both managed by the harness. Common abstractions for memory have not yet emerged. The field is still figuring out what memory even means for agents.

The Lock-In Spectrum

Closed harnesses create lock-in through memory at three levels of severity:

  1. Mild: Stateful APIs (like server-side compaction) store state on the provider's servers. Switching models means losing the ability to resume previous threads.
  2. Bad: Closed-source harnesses interact with memory in unknown ways. Even if artifacts are created client-side, their shape and usage patterns are proprietary and non-transferable.
  3. Worst: The entire harness, including long-term memory, is behind an API. You have zero ownership or visibility into memory.

Model providers are incentivized to push toward the worst end of this spectrum. Anthropic launched Claude Managed Agents, putting everything behind an API. OpenAI's Codex generates encrypted compaction summaries not usable outside the OpenAI ecosystem.

Without memory, agents are easily replicated by anyone with the same tools. With memory, agents build a proprietary dataset of user interactions and preferences. Memory is the primary source of differentiation and lock-in for agentic products.

Why Memory Matters

Chase describes losing an internal email assistant agent when it was accidentally deleted. Recreating it from the same template produced a much worse experience. All learned preferences, tone, and behaviors had to be retaught from scratch. The experience demonstrated how much value accumulates in memory and how sticky it makes the agent.

This aligns with what llm-knowledge-bases describes: persistent, compounding knowledge artifacts are more valuable than stateless retrieval. The same principle applies to agent memory.

Real-World Example: OpenClaw

OpenClaw (built on the open-source Pi harness) demonstrates agents applied to physical-world business automation. One user built an agent that finds $500K-$1.2M homes without pools, renders a pool in the backyard using AI, and mails personalized before/after postcards on autopilot. The discussion around this example highlighted two points: the agent handles lead generation and personalization, but human trust is still needed to close large deals; and production agents doing outreach require consent verification hooks and suppression list checks at the tool level.

Source: @shiri_shh

Related Topics

  • context-engineering - Memory as a form of persistent context
  • agentic-engineering-best-practices - Harness design and context management principles
  • building-ai-agents - Agent architecture and tool patterns
  • llm-knowledge-bases - Persistent knowledge as a form of long-term memory
  • scaling-autonomous-coding - Multi-agent harness coordination at scale