ZeroClaw vs OpenClaw: deployment, permissions, and where the cost is

ZeroClaw and OpenClaw are both free, self-hosted, open-source agent runtimes, so the choice is not about price: it is between ZeroClaw's single Rust binary that asks before it acts, and OpenClaw's Node-based gateway, with a far wider channel and plugin surface, that does not gate tool execution until you configure it to. Choose ZeroClaw for a small service-installed runtime with an approval gate on by default and a per-agent cost ledger. Choose OpenClaw for the larger channel, plugin and desktop ecosystem, accepting that permission modes and sandboxing are your setup work.

Neither project sells anything: ZeroClaw's "what this isn't" page says there is no hosted version, no account system and no billing, and OpenClaw's FAQ says the Foundation has no paid tier, no hosted service and no token. The money in both cases is model tokens plus the host, and that part of the decision is identical for both — which is why most of this page is about deployment, permissions and configuration instead.

Identify the official project before you trust any number

ZeroClaw's only official repository is zeroclaw-labs/zeroclaw, maintained by ZeroClaw Labs, written in Rust on the master branch, with zeroclaw.com as its declared homepage. The README publishes an impersonation notice stating that this is the only official repository and that any other repository, organization, domain or package claiming to be ZeroClaw is unauthorized and not affiliated with the project.

That notice exists because there is a fork at github.com/openagen/zeroclaw and two marketing sites, zeroclaw.dev and zeroclaw.org, carrying the same set of unofficial figures. Every GitHub link on zeroclaw.org points at that fork and never at zeroclaw-labs; zeroclaw.dev's links point at zeroclaw-labs instead. Their figures contradict the official documentation either way: both advertise a 3.4MB binary where ZeroClaw's own philosophy page says a typical release build lands around 26 MiB, and both advertise 22+ AI providers where zeroclaw.com says 70+ LLM Providers. The two sites also disagree with each other about OpenClaw: one gives its binary as about 28MB, the other as about 150MB. Do not carry any resource comparison from those pages into a decision.

One thing we could not settle: the official README names security@zeroclaw.dev as the security contact, so ZeroClaw Labs plausibly holds that email domain even though the website at it publishes figures the project's own documentation contradicts. Ownership of that web property is unverified here. Treat zeroclaw.dev as not citable for facts, not as a proven impostor.

On the other side, openclaw/openclaw is the AI agent, stewarded by the OpenClaw Foundation. Three separate mix-ups are worth knowing about. pjasicek/OpenClaw is a C++ reimplementation of a 1997 platform game and has nothing to do with it. OpenClaw is not OpenAI's product: its own FAQ says the Foundation is an independent 501(c)(3) funded by donations with no product to sell, and that OpenAI is one of several donors. And the project has been renamed four times — Warelay, CLAWDIS, Clawdbot, Moltbot, then OpenClaw — so a Clawdbot-era tutorial may not match current config keys.

Two sources also disagree on the current version. Wikipedia's infobox still lists 2.0 (v2026.8.1, August 30, 2026) as the latest release, while the GitHub API returns v2026.9.5 published September 19, 2026. Check the repository's releases page rather than an encyclopedia summary before pinning a version.

Who should pick which

Pick ZeroClaw if the runtime has to sit on a machine you keep small and boring — an SBC, a VPS, a box where installing and upgrading a Node runtime is itself the maintenance you are trying to avoid. It installs as a prebuilt native binary and, per its service documentation, registers itself with systemd, launchd or Windows Task Scheduler via zeroclaw service install. You accept a smaller ecosystem, a configuration model that refuses to start on an unresolved reference, and no commercial support offer at all: the project's contributor documentation answers the paid-support question with "None offered."

Pick OpenClaw if what you actually want is reach — chat channels, ClawHub as the public registry for skills and plugins, the macOS menu-bar app and the Windows Hub companion, and the volume of third-party material that comes with a project of its size. You accept a JavaScript runtime as a dependency — Node 24.16+ or 26.1+, with Bun 1.4+ as an explicit opt-in — a JSON5 configuration with more moving parts per provider, and the job of choosing a permission mode, because it will not choose a restrictive one for you.

On execution permissions, ZeroClaw is the conservative default and OpenClaw is the permissive one. On protocol limits, both reach a third-party endpoint through a documented custom-provider route, and both document the vendor subscription paths as a separate thing from it — those paths authenticate with the vendor's own credential rather than your gateway key. On cost path, ZeroClaw meters spend itself in an append-only ledger with per-agent budgets; OpenClaw books a custom model at zero unless you type the rates in. On migration cost, nothing carries across: TOML and JSON5, different provider grammars, different permission vocabularies.

Project facts, side by side

Release, star and fork figures were read from the GitHub API on September 21, 2026 and drift daily; the date is part of the figure. The GitHub API reports ZeroClaw's license as Apache-2.0 only, because its single-file heuristic sees one of the two LICENSE files; the README badge and both license files establish the dual grant. It reports OpenClaw's as NOASSERTION because the LICENSE file appends a third-party-notices line to an otherwise standard MIT text.

ZeroClaw's own provider count is inconsistent across its sources: the README says it talks to Anthropic, OpenAI, Ollama "and ~20 others", while zeroclaw.com says 70+ LLM Providers. The canonical slot list on the provider catalog page is generated at documentation build time, so count it there yourself rather than trusting either headline.

The permission models are genuinely different

ZeroClaw puts autonomy on a named risk profile at [risk_profiles.<alias>].level that each agent must reference. The autonomy documentation accepts exactly three values — readonly, supervised and full — with supervised as the default: low-risk tools run automatically, medium-risk tools raise an operator approval prompt, and high-risk tools are blocked. Approval prompts arrive on the channel that started the conversation and expire after approval_timeout_secs, typically 120 seconds, and a timeout counts as a denial. That last detail matters for an unattended agent: an unanswered prompt does not queue, it fails closed.

OpenClaw is the other way round. Its sandboxing page says sandboxing is off by default, controlled by agents.defaults.sandbox, and that the Gateway process always stays on the host while only tool execution moves into a sandbox when enabled. The permission-modes page is blunter still: without those settings or sandboxing, the default is full access. Its four session modes are read-only, guarded, workspace and full.

This is not a claim that OpenClaw is careless. Its security page documents conservative network and identity defaults — the Gateway binds to loopback on a regular host install, most chat channels answer an unknown direct-message sender with a pairing code instead of processing the message, and group access is allowlisted, usually behind a mention gate — with container images as the documented exception that defaults to an exposed bind. The honest summary is that OpenClaw defends the front door by default and leaves the tool gate open, while ZeroClaw ships the tool gate closed.

One warning about comparison tables, including ZeroClaw's own. The OpenClaw column of ZeroClaw's published feature matrix is hand-maintained and was source-walked on July 6, 2026 against an OpenClaw commit that predates OpenClaw 2.0 on August 30, 2026. Its assertions about OpenClaw describe a July snapshot, and the file itself records that date and the exact commit walked. To ZeroClaw's credit the evidence is dated at all, and the file says a re-walk diffs that fixed commit rather than re-verifying from scratch — but the recorded date is still July. Verify any parity cell against the current documentation before acting on it. OpenClaw's own documentation publishes no counter-comparison — ZeroClaw appears in it only as an ACP agent you can point OpenClaw at — so there is no second table to cross-check against.

Pointing either one at a third-party model endpoint

ZeroClaw addresses every model provider at [providers.models.<type>.<alias>], where <type> is a canonical family slot with one key per vendor and no synonyms, and <alias> is yours to name. The provider overview is explicit that there is no global default provider or model: every agent names a model_provider and a risk_profile, and Config::validate() fails at startup if a reference does not resolve.

There are two routes for an OpenAI-compatible or Anthropic-compatible gateway. The custom-provider page says that if the service speaks OpenAI chat-completions this is a config-only change, and that the custom slot requires uri because its endpoint enum has no default. The provider catalog says Anthropic-compatible proxies go on the canonical anthropic slot instead, with uri set to override. Kunavo serves both shapes — /v1/chat/completions and /v1/messages — under https://api.kunavo.com/v1 with one sk-kn- key, so either slot is available to you.

The README describes the smallest valid configuration as at minimum four <type>.<alias>-shaped section headers, and enumerates three of them: a provider entry, an agent that references it and a risk profile the agent gates against. The "canonical four-section form" it links to renders as prose with no example block in the published documentation, so what follows is our reconstruction of those three from the field reference, not a copied official snippet. Build the real one with zeroclaw config set, the gateway or zerocode as the documentation instructs, and use this only to recognize the shape.

[providers.models.custom.kunavo]
uri     = "https://api.kunavo.com/v1"
api_key = "sk-kn-..."
model   = "claude-sonnet-5"

[agents.main]
model_provider = "custom.kunavo"
risk_profile   = "cautious"

[risk_profiles.cautious]
level = "supervised"

Two sharp edges. custom, llamacpp and OpenAI-compatible vendor slots default to the chat-completions wire and those families plus the openai slot are the ones that honor wire_api; branded vendor slots have a fixed wire and ignore the field, with opencode named as the one documented exception. And connection warmup issues GET {base_url}/models with the same auth but accepts non-success statuses, so a successful start does not prove the model route works — check with zeroclaw models refresh and one real message.

OpenClaw takes a models.providers.<id> entry with baseUrl, apiKey (which supports ${ENV_VAR} interpolation), api set to openai-completions or anthropic-messages, and a models[] array. Registering the provider is not enough on its own: the custom-provider reference notes that per-model metadata under agents.defaults.models neither restricts overrides nor registers a runtime model, so the models[] entry with a matching id has to be there too, and an agent then selects it as provider/model.

{
  "models": {
    "providers": {
      "kunavo": {
        "baseUrl": "https://api.kunavo.com/v1",
        "apiKey": "${KUNAVO_API_KEY}",
        "api": "openai-completions",
        "models": [
          {
            "id": "claude-sonnet-5",
            "name": "Claude Sonnet 5",
            "input": [
              "text"
            ]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "kunavo/claude-sonnet-5"
      }
    }
  }
}

That snippet is deliberately incomplete. OpenClaw defaults a custom provider model's cost to zero for input, output, cache reads and cache writes when the block is omitted, so spend reporting will read as free while the provider bills normally. Add a cost block with the rates from the Kunavo catalog before you trust any figure OpenClaw shows you.

Two further behaviours are worth knowing before you debug something that is working as designed. For openai-completions on a non-empty baseUrl whose host is not api.openai.com, OpenClaw forces compat.supportsDeveloperRole: false and skips OpenAI-only request shaping. For anthropic-messages on a non-direct endpoint it suppresses implicit Anthropic beta headers so that custom proxies do not reject unsupported flags; if you need one, set it yourself under models.providers.<id>.headers. Which beta values a Kunavo route would need, if any, is untested here.

A vendor subscription is a different credential, not a base URL you can redirect. ZeroClaw's Codex path requires a stored OpenAI auth profile with requires_openai_auth = true and no API key, and Claude Max requires a claude setup-token credential on the anthropic slot, both per the provider configuration page; OpenClaw's Codex routing page says that with the runtime unset or auto, only an exact official Platform Responses or ChatGPT Responses route with no authored provider request override may select Codex implicitly — so pointing that harness at a gateway URL is not one of the documented routes.

Host cost and model cost are two different bills

Because neither project charges for software, the only recurring numbers are the machine and the tokens. Those are not interchangeable and no runtime choice moves the token price. What is checkable is the install requirement: ZeroClaw's installer prefers a matching prebuilt binary and falls back to a source build, so no language runtime is needed at run time, while OpenClaw requires Node 24.16+ or 26.1+ and its installer provisions Node when missing. ZeroClaw's documentation also asserts that production deployments run 24/7 on homelab SBCs, VPSes and cloud VMs, but that is a project claim with no evidence attached. On the other side, OpenClaw's hosting FAQ gives a sizing floor rather than a measurement: minimum 1 vCPU, 1 GB RAM and about 500 MB of disk, recommended 1–2 vCPU and 2 GB+ RAM for headroom. A minimum spec is what the project will support, not what the process uses, and we have measured neither product — so the resident-memory and binary-size numbers the lookalike sites quote for both remain unsourced.

For the token side, take a scheduled agent running 720 turns a month — one an hour — each sending 8,000 uncached input tokens and returning 400. That is 5.76M input and 0.288M output tokens. At current Kunavo catalog rates, Claude Sonnet 5 at $2.00 per million input and $10.00 per million output works out to $14.40, and Claude Haiku 4.5 at $0.40 / $2.00 to $2.88.

This is token arithmetic on assumed volumes, not a measured task cost and not a ceiling on your bill. It excludes cache charges, tool calls and retries, and it assumes the cheaper model finishes the work without extra attempts — which is the condition that decides whether a lower listed rate produces a lower total. A cheapest listed price and the lowest cost to finish a task are different claims. The minimum Kunavo top-up is $10 in prepaid credit, not a subscription; see billing for how a catalog estimate relates to the final charge.

The two runtimes do differ in how visible that spend is. ZeroClaw's cost tracking records every token-bearing model call to an append-only ledger, attributes it to the originating agent and enforces daily and monthly budgets over the priced portion, with rates kept in config under [cost.rates.*] keyed by the upstream model id. It can also set live_pricing = true on a provider block to read per-token prices from that gateway's own /models listing instead of a hand-maintained sheet — off by default. OpenClaw's custom-provider reference documents no equivalent price source for a provider you registered yourself — the rates are the ones you typed in — which is why the zero-cost default above matters.

Failover differs in the same direction. ZeroClaw configures it on the provider alias itself: fallback_models for alternate model IDs on the same alias, fallback for an ordered list of other dotted aliases. OpenClaw runs auth-profile rotation inside the current provider first, then model fallback to the next entry in agents.defaults.model.fallbacks, and that fallback is turn-local rather than persisted as the next turn's selection. Either way, a fallback route can move work to a different price tier, so give it a budget before you enable it.

What a migration actually costs

Assume nothing transfers. The configuration languages differ (TOML against JSON5), the provider grammar differs (providers.models.<type>.<alias> against models.providers.<id> plus a models[] entry), and the permission vocabularies do not map onto each other — ZeroClaw's three autonomy levels against OpenClaw's four session modes plus an independent sandbox switch. Channel credentials, scheduled work and any skills or plugins are separate assets to move by hand, and ClawHub packages do not port: ZeroClaw's extension story is a WASM plugin model with its own distribution documentation, where a registry is a JSON index consulted by zeroclaw plugin search and install — commands that exist only in builds with the plugin host compiled in, which the prebuilt release binaries are not.

What does transfer is the model route. If you hold an API key at one endpoint, both products can be pointed at it from configuration, which makes a side-by-side trial cheap: run the same scheduled task on both for a week against the same key and compare what each one reports. That trial is also the only way to answer the compatibility question for your own workload — Kunavo has published no runtime test of either client, and every configuration claim on this page comes from the vendors' own documentation rather than from a request we made.

If you want that route, create a key and fund the minimum top-up at Kunavo signup, then use the Messages endpoint reference or the OpenAI-compatible API guide for whichever wire your chosen client speaks. For OpenClaw specifically, best API for OpenClaw works through the provider choice in more detail and OpenClaw pricing breaks down the full operating bill.

FAQ

Repository metadata and releases were re-read from the GitHub API on September 21, 2026; documentation quotes were checked against the zeroclaw-labs repository and docs.openclaw.ai on September 18 and re-checked September 21, 2026. Kunavo token rates are read from the live catalog and the worked totals are illustrative estimates. Kunavo has not runtime-tested either client.