Claude Code Is Replacing OpenClaw as the Default Runtime for Always-On Agents

As of 12:00 PM PT today, using your Claude Pro or Max subscription to power OpenClaw, NanoClaw, or any similar third-party agent runtime is a violation of Anthropic's Consumer Terms of Service. The ban has been in the works for months. It's now fully enforced.

If you built on OpenClaw, you've had two options for a while, and neither has been good.

Option one: pay the Anthropic API bill directly. OpenClaw-class agent runtimes are token-hungry by design. They run continuously, carry large context windows, re-ground on memory stores, and chain tool calls across long sessions. The pay-as-you-go bill for a handful of always-on agents on the API can run into the thousands of dollars a month per agent. For a small team or a bootstrapped business, that's not a rounding error.

Option two: point OpenClaw at the OAuth token from your Claude Max subscription and hope nobody notices. That's what a lot of people did. It worked for a while. Then Anthropic started rolling out server-side enforcement, accounts started getting suspended, and anyone who had built their operations on top of this setup had to scramble.

As of today, that workaround is dead. Anthropic's updated terms explicitly state that "using OAuth tokens obtained through Claude Free, Pro, or Max accounts in any other product, tool, or service, including the Agent SDK, is not permitted."

The obvious question: if the subscription path is closed and the API path is too expensive, where do you run your agents?

The Gap Closed While Nobody Was Watching

Here's the part most people missed. Over the last six months, Anthropic has been quietly adding features to Claude Code, its official terminal coding agent, that close the gap between "a coding assistant" and "a full agent runtime." Three features in particular:

Auto memory. Claude Code now supports custom memory directories, timestamped memory files, and an indexed MEMORY.md that loads at the start of every conversation. Memory persists across sessions. It's not a vector database, it's markdown files, but for the vast majority of memory use cases (who is the user, what are they working on, what conventions apply, what happened last time) this is the right abstraction. It's auditable, editable by hand, and doesn't require running a separate service.

Loops. The /loop command turns Claude Code from a request-response chat into a continuously running background worker. It's a lightweight cron scheduler built into the agent itself. You can hand Claude Code a prompt and a cadence, and it will execute that prompt on schedule, with its full memory and tool context intact.

Channels. A permission-relay system that lets channel servers forward tool approval prompts to your phone or another surface. This is the piece that makes Claude Code trustworthy as a long-running service rather than something that needs a human at the keyboard. You can approve risky actions remotely, route alerts, and wire agent actions into your existing notification systems.

Each of these features is individually modest. Together, they do something specific: they replicate the load-bearing capabilities that made dedicated agent runtimes necessary, and they do it inside a client that runs under your existing Claude subscription, within Anthropic's terms of service.

This is huge news for anyone who was running OpenClaw-class infrastructure.

What an Always-On Claude Code Agent Actually Looks Like

At VantaSoft, we run a constellation of always-on Claude Code agents. Each one has a role (chief of staff, finance, marketing, coding, personal assistant), and each runs in its own tmux session with its own working directory, its own memory folder, its own CLAUDE.md describing its scope and guardrails, and its own set of installed plugins.

The architecture is almost embarrassingly simple:

• One directory per agent on the host
• One tmux session per agent, kept alive by systemd
• An OS-level cron entry that fires a heartbeat prompt into each session on a schedule, telling the agent to run recurring tasks
• Per-agent plugin lists (Telegram, Gmail, Google Workspace, MCP servers) in settings.local.json
• Memory files in each agent's memory/ directory that persist across conversations

That's the whole platform. No orchestrator, no queue, no separate memory service, no framework. The "runtime" is tmux and cron. Messages arrive from Telegram, the agent reads them, reasons about them, takes actions, replies. Scheduled work runs on the heartbeat. Memory accumulates as markdown. When an agent learns something about the principal, it writes it down. The next conversation starts with that file in context.

This exists under a single Claude Max subscription, within Anthropic's terms, without a pay-per-token bill that scales with usage.

We've open-sourced the scaffolding for this setup as claude-code-teams. It's a template for running a team of persistent Claude Code agents, each with its own personality, memory, and Telegram interface, coordinated by a chief-of-staff orchestrator. Clone it, point it at your own Max account, and you have the skeleton of an agent stack running on your own hardware by the end of the afternoon.

Why This Matters for Anyone Building on Agents

The OpenClaw ban isn't just a legal technicality. It's Anthropic saying, loudly, that they do not want their subscription model powering third-party agent runtimes. Fine. But they're simultaneously building first-party agent runtime features directly into Claude Code. If you were relying on the subscription-OAuth workaround, the transition path isn't "pay the API bill." It's "port your agents to Claude Code."

For a technical consultancy advising non-technical founders, this shift changes the advice we give. A year ago, "build your own AI agent" meant committing to a platform, hiring people who know it, and standing up infrastructure. Today, the marginal cost of standing up a new agent, with its own memory, its own access rights, its own integrations, is measurable in hours. The ceiling is set by how clearly you can describe the job and what systems the agent can touch, not by the plumbing underneath.

The implications compound. If every function in your business can have a dedicated agent with persistent memory, running under a subscription you already pay for, the calculus of what's worth automating changes. Tasks that were previously "not worth building for" because the integration overhead dwarfed the value now clear the bar easily. A finance agent that reconciles one spreadsheet a week used to need a platform commitment. Now it needs a directory and a cron entry.

What to Watch For

Claude Code isn't a full replacement for dedicated agent platforms in every scenario. If you need fine-grained multi-tenant isolation, complex approval workflows, enterprise audit logs at scale, or a polished end-user UI, a purpose-built system still has a role. The gap has narrowed, it hasn't disappeared.

One specific gap worth calling out: channel coverage. As of this writing, Claude Code's first-party channel support is limited to Telegram and Discord. OpenClaw and similar runtimes ship adapters for Slack, WhatsApp, Microsoft Teams, SMS, and email out of the box. If your operators live in Slack and you need the agent reachable there today, you'll either wait for first-party support, build your own channel bridge via MCP, or stand up a thin relay. The direction of travel is obvious (more channels are coming) but the current state is Telegram and Discord only.

But for the much larger set of use cases, internal agents serving specific operators, handling specific workflows, remembering context over time, the platform tax is no longer justified. Claude Code, memory markdown, tmux, and cron will get you there. The result is simpler to reason about, easier to modify, and runs under a pricing model that doesn't punish you for using it.

The OpenClaw ban closes a door. Anthropic's Claude Code roadmap, quietly, opened a better one.