The Agent Harness.

One emits a turn. The other never sleeps.

Every agent needs a loop. Claude Code runs a fresh one per task and tears it down at end_turn. OpenClaw runs a single daemon that stays up for days, waking whenever a message arrives. Step through the same five beats and watch where they diverge.

# 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

One compresses to survive. The other remembers on disk.

Claude Code fights a fixed window. Before each model call it runs five compaction shapers, cheapest first, and only summarizes as a last resort. There is no single magic threshold. OpenClaw barely has this problem: its memory is plain Markdown and YAML on disk that outlives 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

Same format. Different appetite.

Both speak the same dialect: a SKILL.md file with YAML frontmatter, progressive disclosure, and MCP for everything else. The difference is what the tools reach for. Claude Code aims at a codebase. OpenClaw aims at your life, and pulls skills from a public marketplace.

One spawns to forget. The other lives in parallel.

Claude Code spins up a subagent in a fresh, isolated window, lets it do the expensive work, and keeps only the summary. It is an escape valve for context. OpenClaw runs many agents at once, one per channel or peer, each long-lived and sandboxed. Press spawn to watch Claude Code's version.

One fires from inside. The other from outside.

Claude Code's hooks live inside a single session's lifecycle: deterministic shell escapes wired to named events. OpenClaw's triggers come from the outside world and wake the agent: cron, webhooks, an inbound message.

One gates every call. The other gates who can call.

Claude Code checks each tool call against rules and, in auto mode, a separate classifier model. OpenClaw starts a level up: it decides who is even allowed to talk to it, then sandboxes everyone who is not you.

One rides in your repo. The other lives with the daemon.

Both are file-driven, no database. Claude Code's config lives in .claude/ inside the repo, committed and shared with the team. OpenClaw's lives in ~/.openclaw on whatever host runs the always-on daemon.

One meets you at work. The other in your chats.

Claude Code is the same harness on three substrates inside your dev environment. OpenClaw is one self-hosted Gateway that bridges into the messaging apps you already live in.

One had to be decompiled. The other ships its source daily.

The reason we can write any of this down differs sharply between the two. One harness we know only because it leaked. The other we know because it was open from day one.

The harness is the interesting part.

A language model on its own is a function. What turns it into an agent is the orchestration around it: the loop, the context discipline, the tools, the permissions, the surfaces. Claude Code and OpenClaw make almost opposite choices at every layer, and both work.

One is a closed, single-task loop you run in your terminal, reconstructed from a leaked source map. The other is an open, always-on daemon that lives in your chats, readable in full on GitHub. Same model. Two bodies.

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