Anthropic Dropped OpenClaw Support. Here's How I Replaced It With Claude Code.

Anthropic recently changed their Terms of Service, effectively killing OpenClaw. This wasn't a gradual sunsetting or a slow loss of momentum - the project was active and the community was thriving. It stopped abruptly because of a policy change. I believe this is the end of OpenClaw as we know it, and it leaves a lot of users figuring out what comes next.

I was one of those users. As co-founder of The Gnar, I don't get to focus as much on IC work anymore. So when I do get to write code, it's usually on internal tools or side projects. OpenClaw had become a big part of that. Home automation, side project scripting, general tinkering - I was an early adopter and had invested real time getting it stable enough to use as a daily driver.

The catch: I never trusted it enough to run on my work machine. It always lived in an isolated Docker container in my home lab (named Pinchy, naturally) where it could operate without me worrying about what it had access to. That security-first instinct turned out to be useful when it came time to migrate.

The Economics Problem

With the TOS change, running OpenClaw going forward means doing it without Anthropic's support. And the economics of that aren't pretty. Running it via API calls is prohibitively expensive, and using an alternative backend like Gemini is still very costly for what amounts to a personal assistant. The long-term viability just isn't there.

At work, I rely on Claude and have been impressed by the progress Anthropic has been making toward more autonomous agents and the tooling around them. So the natural question was: could Claude Code replicate the isolated, containerized assistant experience I had with OpenClaw?

ClawChat: The Client That Made This Possible

Some context on my setup. Most people interacted with OpenClaw through Discord or other community channels. I'm old and don't have Discord friends, so I built ClawChat - an Electron app (React + TypeScript, built with Vite) that handled about 95% of my OpenClaw interactions.

ClawChat connects to backends over WebSocket, handles the Ed25519 crypto handshake for OpenClaw's gateway protocol, supports streaming deltas, and stores credentials locally via electron-store. It has SSH tunneling for remote connections and all the slash commands you'd expect. Nothing groundbreaking, but it was purpose-built for how I actually wanted to use an AI assistant: from a dedicated desktop app, not a chat platform.

Having this abstraction layer between me and the backend turned out to be the key to a smooth migration. The client didn't care what was on the other end of the WebSocket - it just needed to send messages and receive responses.

Claude Code Channels as a Drop-In Backend

Claude Code's new channels feature turned out to be exactly the bridge I needed. Channels let you communicate with a Claude Code instance programmatically through MCP (Model Context Protocol), which meant I could wire up ClawChat to talk to Claude Code the same way it talked to OpenClaw.

Here's the architecture:

A Docker container running node:22-slim with Claude Code installed, a workspace volume mounted, and port 9700 exposed. It needs a Claude Max subscription OAuth token (generated via claude setup-token) passed through a .env file.

An MCP channel server (server.mjs) that serves as the bridge:

1. Connects to Claude Code over stdio using the channel capability
2. Exposes a WebSocket server on port 9700 for ClawChat to connect to
3. Translates between ClawChat's message protocol and MCP channel notifications

The server registers a send_reply tool that Claude uses to push responses back through the channel. The MCP config is minimal:

json

{
 "mcpServers": {
   "channel-test": {
     "command": "node",
     "args": ["/workspace/channel-test/server.mjs"],
     "env": { "CHANNEL_PORT": "9700" }
   }
 }
}

Claude Code launches with --dangerously-load-development-channels to enable the channel server. The flag name is a bit alarming, but channels are still in development preview.

The message flow: ClawChat sends a chat.send request -> channel server acknowledges with a runId -> forwards via MCP to Claude Code -> Claude calls send_reply -> server broadcasts as a chat event -> ClawChat renders the response.

Adding Claude Support to ClawChat

On the client side, the changes were surprisingly minimal. PR #26 covers the full implementation. The main additions were a BackendType union type ('openclaw' | 'channel') threaded through the gateway client, hooks, and connection screen; a tabbed connect interface for switching between backends; separate credential storage for each; and bypassing the Ed25519 handshake for the channel path since MCP handles auth differently. All 12 existing tests passed, TypeScript compiled clean.

For anyone maintaining a similar client app that talks to OpenClaw, the pattern here is straightforward: abstract your transport layer, add a backend selector, and let the channel server handle the protocol translation.

Migrating the Configuration

OpenClaw used a handful of markdown files to define its behavior - SOUL.md for personality and tone, plus config files for tool permissions, task patterns, and behavioral guardrails. Claude Code has its own equivalent: it reads a CLAUDE.md file automatically at the start of every session.

Rather than manually translating each file, I pointed Claude Code at the OpenClaw markdown files and had it do the analysis itself. It looked at what each file was doing, figured out the Claude Code equivalents, and consolidated everything into a single CLAUDE.md that made sense from a compatibility perspective. Some concepts mapped directly, others needed rethinking for how Claude Code handles tool access and autonomy levels, but the end result captured the spirit of my OpenClaw setup without hand-translating a bunch of config.

Honest Assessment

This isn't a seamless replacement yet. There are real limitations: no streaming (responses arrive as a single event rather than incremental deltas), single conversation per instance, and a manual warning prompt to accept after each container restart.

But it works better than I expected as a daily driver for personal use. The responses are solid, the isolation model gives me the same security boundary I had with Pinchy, and I have access to all the new features Anthropic keeps shipping. I suspect that within the next few weeks, as channels matures, this setup will reach decent parity with how I used OpenClaw.

The TOS change hit different parts of the OpenClaw ecosystem very differently. Businesses that were built on top of it - tooling providers, hosting services, managed platforms - essentially evaporated overnight. That's a real cost and it's worth acknowledging. But for end users like me who were running OpenClaw as a personal tool, the story is more hopeful. Claude Code plus channels provides a viable path forward. It's not a one-to-one replacement, but it's a foundation that's actively improving and backed by a company that's investing heavily in this space.

The ClawChat repo has the Docker Compose config, channel server code, and setup docs. If you're comfortable running containers and wiring up WebSockets, the migration is more approachable than you might think.

‍