The Agent Harness.

Claude Code runs one loop per task. OpenClaw runs one loop that never stops.

Every agent needs a loop: the model asks for a tool, the harness runs it, and the result goes back to the model. Claude Code starts a fresh loop for each task and ends it when the model replies with end_turn. OpenClaw runs a single daemon that stays up for days and wakes whenever a message arrives. Step through the same five steps for both harnesses and see where they differ.

# Claude Code: one ephemeral loop per task
def run_task(prompt):
    messages = [user(prompt)]
    while True:
        reply = model(messages)           # think
        messages.append(reply)
        if not reply.tool_calls:          # text only -> done
            return reply                  # stop_reason: "end_turn"
        for call in reply.tool_calls:     # act
            messages.append(run_tool(call))  # observe, then repeat

# OpenClaw: one daemon, never sleeps
while True:                     # the Gateway
    event = inbox.get()        # a message, cron tick, or webhook
    agent = route(event)       # pick the per-channel agent
    agent.handle(event)        # runs its own loop, then waits

Claude Code shrinks its history to fit. OpenClaw writes its memory to disk.

Claude Code works inside a fixed window: the model can only see so many tokens at once. Before each model call it tries five compaction steps, called shapers, cheapest first, and stops as soon as the history fits. There is no single fill level that sets this off, and writing a summary is the last resort. OpenClaw mostly avoids the problem, because its memory lives on disk as plain Markdown and YAML files that last longer than any one session.

# Claude Code: shrink history cheapest-first, stop once it fits
SHAPERS = [budget_reduction, snip, microcompact,
           context_collapse, auto_compact]

def fit(messages, limit):
    for shape in SHAPERS:
        if tokens(messages) <= limit:
            break              # fits now, stop early
        messages = shape(messages)
    return messages

Both use one skill format. Claude Code's tools work on code. OpenClaw's work on your life.

Both harnesses package skills the same way: a SKILL.md file with a YAML header (frontmatter), loaded by progressive disclosure. Both use MCP to plug in any other tool. The difference is what the tools act on. Claude Code's tools work on a codebase. OpenClaw's tools work on the rest of your life: your browser, your schedule, your chat apps. OpenClaw can also install skills from a public marketplace.

Claude Code's subagents are short-lived helpers. OpenClaw's agents run side by side for days.

Claude Code starts a subagent in a fresh, separate context window, lets it do the work that uses up lots of tokens, and keeps only its summary. That way the main conversation does not fill up. OpenClaw runs many agents at once, one per channel or per peer (the person or group on the other end). Each one is long-lived and sandboxed. Press spawn to watch Claude Code's version.

Claude Code's hooks react to events inside a session. OpenClaw's triggers come from outside.

Claude Code's hooks are shell commands you attach to named events in a single session, such as the moment before a tool runs. They run every time their event happens, whatever the model wants. OpenClaw's triggers come from the outside world and wake the agent up: a cron schedule, a webhook, or a new message.

Claude Code checks every tool call. OpenClaw checks who is allowed to talk to it.

Before a tool call runs, Claude Code checks it against your rules. In auto mode, a separate classifier model checks it too. OpenClaw starts one step earlier. It first decides who is allowed to talk to it at all, then puts everyone who is not you in a sandbox.

Claude Code keeps its config in your repo. OpenClaw keeps it on the machine that runs it.

Both are configured with plain files. Neither uses a database. Claude Code's config lives in .claude/ inside the repo, where it is committed and shared with your team. OpenClaw's lives in ~/.openclaw on whichever machine runs the always-on daemon.

Claude Code runs where you write code. OpenClaw runs in your chat apps.

Claude Code is one harness that runs in three places in your dev environment: your terminal, your editor, and a cloud container on the web. OpenClaw is one Gateway that you host yourself, and it connects to the messaging apps you already use every day.

Claude Code had to be decompiled. OpenClaw publishes its source almost every day.

We know how these two harnesses work for very different reasons. We know Claude Code's internals only because its source leaked. We know OpenClaw's because its code has been open from day one.

The harness is what turns a model into an agent.

A language model on its own is a function: text goes in, text comes out. The code around it is what makes it an agent. That code runs the loop, keeps the context small enough to fit, provides the tools, checks permissions, and connects to the places where you use it. Claude Code and OpenClaw make almost opposite choices at every one of these layers, and both work.

Claude Code is a closed, single-task loop that you run in your terminal, and we know its insides from a leaked source map. OpenClaw is an open, always-on daemon that talks to you through your chat apps, and you can read all of its code on GitHub. Both can run the same model. What differs is the harness.

Claude Code facts come from official docs plus reverse-engineering of the leaked source maps. OpenClaw facts come from its open repo and docs.