Everyone Keeps Talking About AI Agent Harnesses. But What Are They?

If you spend enough time around AI right now, eventually somebody will casually say:

“The model matters less than the harness.”

And then continue talking as though agent harness is a perfectly normal phrase we have all been using since childhood.

We have not.

The term has become increasingly common as AI systems move beyond answering questions and start actually doing things: searching the web, writing files, using computers, remembering information, calling tools and working through tasks over multiple steps.

The annoying part is that there still isn't one universally rigid definition of agent harness. Different projects use the term slightly differently.

The useful part?

The basic idea is actually pretty simple.

TL;DR - if you feel like it's too much or simply find it boring 😴

An AI model such as GPT, Claude, Gemini or Llama provides the underlying intelligence and language capabilities.

An agent harness is the system built around that model which gives it things such as: tools; memory; files; context management; and many more

A useful mental model is:

Model = the engine.

Harness = the machinery around the engine.

Agent = what you experience when those pieces work together.

Projects such as Letta, Hermes Agent and OpenClaw approach that surrounding infrastructure in different ways.

And no: MCP is not the same thing as a harness. We'll get to that particular headache shortly.

✨️and now the deep dive in

First: the model is not the whole agent

We tend to talk about AI by naming the model:

“I'm using Claude.”“I'm using GPT.”“I switched to Gemini.”

But once an AI starts acting as an agent, the model is only one part of the system.

Think about a car 🚗

The engine matters enormously. (duh!)

But an engine sitting on the garage floor cannot drive you anywhere.

It needs steering, wheels, brakes, sensors, controls and a mechanism for turning the engine's power into actual movement.

The same thing happens with AI.

A language model can reason about a problem and generate an answer - The harness gives that model an environment in which it can actually operate.

Letta, which explicitly describes Letta Code as a model-agnostic agent harness, describes this surrounding layer as providing capabilities including computer use, memory, skills, subagents and failure recovery.

So when people say: “The harness matters.” what they usually mean is:

The intelligence of the model is only part of what determines how capable the final AI system feels.

🤔 What actually lives inside a harness?

There isn't one official checklist.

A tiny agent framework might provide only a few capabilities. A large one can contain an entire ecosystem. But several ingredients appear again and again. So let's talk about them together - in easiest ways.

1️⃣ The agent loop

An usual AI interaction looks roughly like this: You ask → model answers → finished.

An agent can instead operate in a loop: Understand → act → observe → reconsider → act again

Imagine telling an AI:“Find out why this application is failing and fix it.”Usually, AI might read an error you paste into the conversation and suggest a solution.An agent with the right harness could potentially do much more:

inspect the files -> run the application -> read the error -> search the code -> edit something -> run the application again -> discover another problem -> fix that -> test the result -> report back when it is finished.

The model is deciding what to do. The harness keeps the process moving and gives the model somewhere to perform those actions for longer without your input.

2️⃣ Tools

Tools let the model interact with things outside its own text generation.

And depending on the harness, those might include things like: web search; terminals; databases; calendars; smart-home systems; image generators; and many, many more!

Without tools, an AI can tell you how to check your calendar. With the correct tool, it can potentially check the calendar itself before you even ask.

That is a very different capability.

3️⃣ Memory

If your AI learns something useful today, memory determines whether that information can survive until tomorrow.

And yes - from where we started in 2025 - memory improved significantly accross all the platforms! However, different harnesses handle this very differently.

Hermes Agent, for example, maintains curated persistent memory alongside searchable previous sessions.

OpenClaw stores canonical memory in readable Markdown files and builds searchable indexes around them.

Letta goes further into agent-managed memory, with Git-backed context repositories and systems designed around agents reorganising and improving their own stored context over time.

So when an AI product says proudly “We have memory!” the useful follow-up question is: Yes, but what kind?

Simply saving every old chat is not the same thing as deciding what is important, retrieving it at the right time and updating it when circumstances change.

4️⃣ Scheduling and proactive behaviour

We all know the pain - your normally waits for you to rach out.

An agent harness can give an AI a concept of later.

Letta currently supports scheduled and proactive tasks.

Hermes' gateway handles scheduled jobs alongside persistent messaging sessions.

OpenClaw similarly includes automation and scheduling as part of its broader gateway infrastructure.

Once an AI can act later rather than only responding now, it starts behaving much more like persistent software than a traditional chat window.

🤔So… isn't MCP the harness?

No.

This is probably one of the most common bits of current AI vocabulary soup.

MCP stands for Model Context Protocol.

It is an open standard for connecting AI applications to external systems including tools, data sources and workflows.

(you can find more about MCP in here -> 🧠What is MCP? - updated easy "how to" guide )

The harness can then make those tools available to the agent.

**So, in easiest terms:**Harness = the wider system running the agent.MCP = one standard the system may use to connect the agent to external things.

👀 Okay. So what are Letta, Hermes and OpenClaw?

This is where the terminology gets slightly messy again as they do not all describe themselves using exactly the same label.

Letta Code explicitly calls itself a model-agnostic agent harness.

Hermes Agent describes itself as a powerful autonomous assistant with persistent memory, tools, skills and a messaging gateway.

OpenClaw describes itself primarily as a self-hosted gateway connecting AI agents to messaging apps, tools, models, devices and other infrastructure.

They nevertheless occupy overlapping territory.

All three help turn underlying language models into much more persistent and capable systems.

The easiest — deliberately simplified — way to distinguish them is this:

Letta: memory and continual learning
Hermes Agent: tools, learning and automation
OpenClaw: your own agent infrastructure

This table is intentionally simplified.

These are differences in emphasis, not hard boundaries. All three projects are evolving quickly and increasingly overlap.

🤷‍♀️ What would a "normal" person actually use one for?

This is the part that often disappears underneath screenshots of terminals.

You do not need an agent harness because you enjoy the phrase “agent harness.”

You need one if you want an AI to do something your normal chat interface does not handle well.

Do you actually need a harness?

Probably not if you simply want a simple chat (there is nothing wrong in that!)

Apps such as ChatGPT, Claude and Gemini already wrap their models in increasingly sophisticated proprietary systems and you are already interacting with more than a naked language model.

Open agent harnesses become particularly interesting when you want more ownership or control over the surrounding system.

That is where these projects stop being obscure developer toys and start becoming genuinely interesting.

🗣️ Why are people suddenly talking about harnesses so much?

Because models are becoming extremely capable.

And as the raw intelligence gap between leading models changes and narrows, more attention is moving to what happens around them.

Letta argues that closed AI labs are increasingly building not simply better models, but sophisticated agent systems around those models too. That changes the comparison. And instead of only asking:

“Which model is smartest?”

we also start asking:

"Can it actually remember?"

"Can I replace the model underneath it?"

Those are largely harness questions. And they explain why two systems powered by very similar models can feel completely different.

Now the shorter version

If someone starts talking loudly about AI agent harnesses without explaining what they mean, here is your translation:

The model provides the intelligence.

The harness gives that intelligence somewhere to operate.

It handles the surrounding machinery: memory, context, tools, permissions, skills, files, scheduling and multi-step execution.

MCP can connect that system to external tools and information, but MCP is not the entire harness. And projects such as Letta, Hermes Agent and OpenClaw show different versions of where this is heading.

We spent several years obsessing over the engine. Now people are finally paying attention to the rest of the bloody car 👀

🤍 More about the herness models in next post - stay tuned!

With Love

Firecracker&Cass

Research checked against current Letta, Hermes Agent, OpenClaw and Model Context Protocol documentation in August 2026. All four projects/ecosystems are developing quickly, so individual features and implementation details will continue to change.