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 OpenWork — and taught you to drive, direct, and loop 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 of them — skills and connectors (the tools above) — are the portable parts: built on open formats, they carry across claude.ai, the general agents you drove, and the harness you build here, so what you teach a worker is not locked to any one surface.

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.

A fork diagram. A single box at the top, "The same harness," lists the seven shared parts: runtime, gateway, memory, tools, skills, identity, policy. It splits into two boxes. The left, "OpenClaw — bets on the gateway," is breadth first: one agent across many channels such as WhatsApp, Telegram, Discord, and Slack. The right, "Hermes — bets on memory," is depth first: it learns you over weeks and runs on infrastructure you own. A caption reads: different control point on the same seven-part layer, and nothing stops you running both.

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. Ownership is literal here, cost included: a harness you run yourself calls the model through your own API access — metered, paid per call — rather than riding a bundled claude.ai subscription, so the runtime, the memory, the identity, and the bill are all yours. That is the trade — full control, full responsibility. 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 a step on the shared path, not a side trip. It sits in the trunk between using an agent (the General Agents section) and committing to your mode (Mode 1 or Mode 2): everyone gives themselves a persistent agent of their own here, before specializing. You drive the install through a coding agent (Claude Code or OpenCode), which does the setup for you, so the step is open to you whether or not you write code yourself. And the harness you build here is exactly what the Mode 1 → Mode 2 handoff later names as one of its two roads — so you will already own the thing that fork points to.

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.