# ClawSuite: A Self-Hosted Control Plane for OpenClaw Agents

> ClawSuite is a TypeScript dashboard that connects to an OpenClaw gateway over WebSocket and gives you mission orchestration, cost tracking and agent memory in one browser tab. The install is short; the dependency on a running gateway is not optional.

**outsourc-e/clawsuite** — All-in-one command center for OpenClaw agents

- Repository: https://github.com/outsourc-e/clawsuite
- Website: https://clawsuite.io
- Stars: 340 · Forks: 59
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/outsourc-e-clawsuite

## The gap ClawSuite fills for OpenClaw operators

OpenClaw agents run as processes behind a gateway. Once you have more than one, the questions stop being about prompts and start being operational: which agent is still running, what did the last mission cost, where is the memory file that keeps drifting. ClawSuite is built around those questions. The README describes it flatly as "Not a chat wrapper. A complete command center", and the repository topics list control-plane alongside desktop-app and vscode-alternative.

The audience is narrow and specific. You need Node.js 22 or newer, an OCPlatform gateway listening locally on port 18789, and a token for it. If you have none of those, ClawSuite has nothing to show you. That is not a weakness in the product so much as a statement about who it was written for: people already running agents and now needing a surface over them.

## How ClawSuite talks to your gateway

The architecture is a server plus a browser client. The ClawSuite server holds the gateway credentials and opens a WebSocket to the gateway; the browser never sees the token. The .env.example is explicit that secrets stay server-side: "Keep secrets here (never exposed to the browser)."

Live output reaches the UI through server-sent events. The v4.0 notes list "Live SSE Streaming" for agent output into Mission Control and chat, with the stated goal of removing polling. Cost figures come from what the release notes call "real gateway data" rather than local estimates, so the dashboard is only as accurate as the gateway's own accounting. Agent memory is read and written as files through the same connection, which is why the Memory Browser can edit memory in place instead of exporting it.

The deployment shape follows from that. Dockerfile runs a three-stage build and finishes as a non-root clawsuite user executing server-entry.js on port 3000. docker-compose.yml maps 3000:3000 and defaults the gateway URL to ws://host.docker.internal:18789 with an extra_hosts entry so the container can reach the host. The gateway is deliberately outside the container.

## Installing ClawSuite and loading the dashboard

The README's quick start is four commands. Clone, install, copy the environment template, then edit it with your gateway URL and token. The token lives in ~/.ocplatform/ocplatform.json under gateway.auth.token, or you can read it with the OpenClaw CLI.

```bash
git clone https://github.com/outsourc-e/clawsuite.git
cd clawsuite
npm install
cp .env.example .env
```

The two required keys in .env are the gateway WebSocket URL and the token. Leave the optional access-control keys empty for a local run.

```env
CLAWDBOT_GATEWAY_URL=ws://127.0.0.1:18789
CLAWDBOT_GATEWAY_TOKEN=your_token_here
```

Start the dev server, which the README says listens on port 3000.

```bash
npm run dev
```

The README's verification steps are worth following literally: open http://localhost:3000, and expect either the dashboard or a setup wizard on first run. A white screen is the documented failure signal, and the README attributes it to a gateway that is not running or an .env that is wrong. If you would rather not install Node locally, the Dockerfile builds the same thing and compose publishes port 3000.

## A gateway dependency that shapes every failure

The clearest limitation is structural: without a live gateway on the other end of the WebSocket, ClawSuite is a shell. The README treats a blank page as the expected symptom of a misconfigured gateway, which tells you how much of the app is gateway-backed. Mission state, spend numbers and memory contents all originate there.

There is a second, quieter constraint around exposure. CLAWSUITE_ALLOWED_HOSTS is documented as both an allowlist and a binding change: setting it also binds the server to 0.0.0.0 instead of 127.0.0.1. The Tailscale recipe in the README leans on exactly this, opening the app at http://100.x.x.x:3000 from a phone. Anyone who sets that variable for convenience and leaves CLAWSUITE_PASSWORD empty has published an interface that can spawn, pause and abort agents to whatever can reach the host. The README marks the password as intended for production deployments, and that framing deserves to be read as a requirement rather than a suggestion.

The native desktop app is a third gap. The README states plainly that an Electron-based app is in active development and suggests the PWA in the meantime. The repository carries electron-builder.config.cjs and electron-builder.standalone.cjs, so the work is real, but the README does not describe it as finished. The managed cloud version is listed as coming soon with no date, and the features it would add (cross-device session sync, shared team memory, managed gateway uptime) are exactly the ones a self-hoster has to assemble themselves.

## ClawSuite against a plain terminal session

The obvious alternative is not another dashboard. It is the OpenClaw CLI plus a terminal multiplexer, which is how most people run agents before they feel the need for a UI. The difference in approach is real: the CLI gives you one agent's output in one pane and no cross-agent view, while ClawSuite keeps a persistent server that aggregates every agent's status, spend and memory behind one connection.

What you give up is directness. A CLI session fails loudly in front of you; ClawSuite fails as a white screen and a log line, as the README's troubleshooting section implies. You also gain a stateful server that must be kept running and secured, which the CLI does not require. For a single agent on a laptop, the terminal is less machinery for the same result. ClawSuite starts to justify itself when the count of agents, or the question of what the month has cost so far, outgrows what you can hold in your head.

## Licence, maintenance and what an upgrade costs you

ClawSuite is MIT licensed, and package.json marks the package private, so this is an application to run rather than a library to publish. MIT is permissive and carries no copyleft obligation on your own code; the practical implication is that you are free to fork and modify, and equally free to be the only one maintaining your fork. That is a description of the licence, not advice about your situation.

The last push to the repository was on 2026-05-23, and the newest release listed is v4.0.0 from 2026-03-27. The README's own version badge still reads 3.0.0 while package.json says 4.0.0, so the documentation trails the code by at least one release. Budget for that when you read feature claims.

Upgrade cost is dominated by the gateway contract, not the UI. ClawSuite's value depends on the WebSocket protocol and the shape of gateway data, and neither is versioned in anything visible here. There is a CHANGELOG.md and a docker-compose.yml with a build directive, so a self-hosted upgrade means pulling, rebuilding the image and restarting the container. If you have set CLAWSUITE_ALLOWED_HOSTS or CLAWSUITE_PASSWORD, re-check them after any change to the compose file, since the environment block is where those live.

## Conclusion

Adopt ClawSuite if you already run an OpenClaw gateway on a machine you control and want orchestration, spend tracking and memory editing in one browser tab rather than several terminal sessions. Do not adopt it if you have no gateway yet, or if you need a supported native desktop binary, since the README labels the Electron app as in development and the cloud version as coming soon. Verify first that your gateway answers on ws://127.0.0.1:18789 and that a token from openclaw config get gateway.auth.token loads the dashboard instead of the setup wizard.

## FAQ

### How do I install ClawSuite?

Clone the repository, run npm install, copy .env.example to .env, fill in CLAWDBOT_GATEWAY_URL and CLAWDBOT_GATEWAY_TOKEN, then run npm run dev. The README says the dev server listens on port 3000. A Dockerfile and docker-compose.yml are also in the repository if you prefer a container.

### What is ClawSuite used for in OpenClaw?

It is a control plane over an OpenClaw gateway: multi-agent orchestration with spawn, pause, resume and abort, live agent output over SSE, per-agent cost analytics, and a memory browser for editing agent memory files. The README frames it as a command center rather than a chat interface.

### How does ClawSuite connect to the OpenClaw gateway?

The ClawSuite server opens a WebSocket to the gateway using CLAWDBOT_GATEWAY_URL, defaulting to ws://127.0.0.1:18789, and authenticates with CLAWDBOT_GATEWAY_TOKEN. The .env.example states secrets stay on the server and are never exposed to the browser. In Docker, the default URL becomes ws://host.docker.internal:18789.

### Why does ClawSuite show a white screen on first launch?

The README lists a white screen as the symptom of a gateway that is not running or an .env file that is incorrect. It also notes that on first launch, if the gateway is not configured yet, a setup wizard appears to help you connect.

### Can I use ClawSuite from my phone?

Yes. ClawSuite is a PWA, and the README documents adding it to the home screen on iOS Safari and Android Chrome. For access away from your local network, the README describes installing Tailscale on both machines, running tailscale ip -4, and opening http://100.x.x.x:3000.

## Sources

- [License: MIT](https://github.com/outsourc-e/clawsuite/blob/main/LICENSE)
- [outsourc-e/clawsuite on GitHub](https://github.com/outsourc-e/clawsuite)
- [Project website](https://clawsuite.io)
- [README](https://github.com/outsourc-e/clawsuite/blob/main/README.md)
- [Releases](https://github.com/outsourc-e/clawsuite/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/outsourc-e-clawsuite