Skip to main content

Personal Agent Harnesses

Open-Source AI Employees You Run and Own Yourself

The previous section handed you general agents (Claude Code, OpenCode, Cowork) and taught you to drive them. Powerful, but bounded. A general agent runs inside a session you open. It works while you watch, and when the session ends, most of its working context ends with it. You are the runtime. Close the laptop and the worker stops existing.

This section removes that ceiling.

An agent harness is the software that turns a model into a worker that runs without you. The harness-engineering literature put it plainly this year: an agent is a model plus a harness. The model answers questions. The harness is what lets it run continuously, remember what it learns across sessions, and call tools to act. It is the layer that will outlast any single model you plug into it, which is exactly why the platform vendors are now fighting over it.

That is the line this section walks you across: from an agent you drive to an agent you own.

What every harness is made of​

OpenClaw and Hermes disagree about almost everything except this. Strip either one down and you find the same anatomy:

  • Runtime: keeps the agent alive between tasks, not just during a chat.
  • Gateway: carries messages in and out, so the agent reaches you where you already are.
  • Memory: persists across sessions, so the agent starts each day knowing more than it did yesterday.
  • Tools: the external capabilities the agent calls to actually do things (MCP servers, APIs).
  • Skills: portable expertise the agent picks up and reuses (the open agentskills.io format, cross-runtime).
  • Identity: who the agent runs as, and what that identity is allowed to touch.
  • Policy & observability: what it may do, and a record of what it did.

Learn this shape once and both crash courses hang off the same frame. Everything you add later (a new channel, a new skill, a scheduled job) is just more of one of these seven.

Two bets on the same layer​

OpenClaw and Hermes are not two tools doing the same job. They are two wagers on which part of the harness is the control point. The difference is emphasis, not exclusivity. OpenClaw has memory and skills; Hermes speaks across twenty-odd channels. But the center of gravity is what defines each one.

OpenClaw bets on the gateway. Breadth first. One agent answers on WhatsApp, Telegram, Discord, Slack, and more from a single place, backed by a large community skills marketplace. It is the project that proved personal AI Employees are real and that people want them. Its strength is reach.

Hermes bets on memory. Depth first. One agent holds your codebase, your conventions, and your past decisions across weeks, develops new skills after a hard task, and refines them as it works. It is built to run persistently on infrastructure you own. Its strength is that it learns you.

The same tradeoff you already know from cloud: a broad, convenient gateway versus a deep, self-managed worker that compounds. You will leave this section able to choose deliberately instead of by default, and able to run both, because nothing here forces an either/or.

Why ownership is the whole point​

There is a quieter argument underneath both courses, and it is the reason this section exists as a peer to General Agents rather than a footnote inside it.

When a harness keeps your agent's memory, identity, and runtime alive, the question stops being "which model is smartest this month" and becomes "who owns the worker I have been training." The platform vendors know this. Microsoft's Scout and Nvidia's NemoClaw wrap these same harnesses in governance and identity: convenient, production-ready, and owned by the vendor. The agent that has learned a year of your habits is the highest switching cost there is. Memory, more than channel reach, is the durable form of lock-in the platform vendors are betting on.

This section teaches the other path: the open-source harness you run yourself, where the runtime, the memory, and the identity belong to you. Not because the vendor wraps are wrong (for a regulated enterprise they are often right) but because you cannot judge that tradeoff until you have built and held the self-owned version with your own hands.

This section is an optional bridge. It sits in the shared trunk between using an agent (the General Agents section) and committing to your mode (Mode 1 or Mode 2). You can build your own harness here and now, or skip straight to your mode and come back when ownership starts to matter. Nothing downstream requires it.

Start here​

Both crash courses share one prerequisite: you drive the harness through a general agent. The Claude Code or OpenCode you learned in Agentic Coding is the thing that installs, configures, and operates the harness for you. The general agent from the last section becomes the installer for the worker in this one. Do the General Agents section first if you have not.

  • OpenClaw with General Agents: 90 minutes, six scenarios, zero to a Personal AI Employee on your phone. The gateway-first harness, hands-on.
  • Hermes with General Agents: the memory-first harness. Persistent context, self-improving skills, an agent that learns your work and stays portable across models.

By the end of this section you will own a worker that answers when you are asleep, remembers what you taught it last week, and runs on infrastructure that is yours. That is the difference between using AI and employing it.