Overview
Install
Architecture
App Views
Backend Routes
Onboarding
Dev
Build & Release
OpenClaw Compat
Market Context
GitHub LLM Wiki
Organized AI · ClawBox v2026.3.17

ClawBox — Desktop client for the OpenClaw Gateway

Tauri v2 shell · React 18 + Vite frontend · Bun / Hono backend. Packages a guided setup wizard and a unified dashboard for chat, sessions, channels, cron, skills, plugins, and Soul editing into a single desktop workflow against an OpenClaw Gateway.

Tauri v2
React 18 + Vite
Bun / Hono backend
MIT licensed
Linux: source build only
macOS: unnotarized releases

What ClawBox solves

OpenClaw ships a Gateway (long-running daemon) plus a set of channels and agents. ClawBox is the desktop skin — it bundles a first-launch setup wizard that can install an app-managed portable Node.js runtime with OpenClaw inside, hooks a chat/session/cron/skills UI to the Gateway via WebSocket RPC, and stays out of the daemon's way so Gateway upgrades don't require a ClawBox rebuild.

Relationship to the Organized Market project
ClawBox is the desktop surface in a family of components. The organized-market project describes the broader marketplace and orchestration story; ClawBox is how humans touch it on their own machine.

At a glance

KeyValue
RepoOrganized-AI/ClawBox (MIT)
Current version2026.3.17
ShellTauri v2 · src-tauri/
FrontendReact 18 · Vite · Tailwind · src/
BackendBun · Hono · internal/
Frontend dev port14200 (Vite)
Backend addresshttp://127.0.0.1:13000
Gateway URLhttp://127.0.0.1:18789/v1
OpenClaw baseline>= 2026.3.12
i18nen + zh (src/locales/)
Phase 01 · Install

Install & First Launch

Two paths — use the prebuilt desktop app (macOS / Windows) or build from source.

Download the desktop app

  • macOS / Windows: latest package from GitHub Releases.
  • Linux: source build only for now.

Choose an environment mode

First-launch wizard offers two options:

  • Portable (Built-in) — recommended for most users. ClawBox prepares an app-managed portable Node.js runtime and installs OpenClaw for you during setup.
  • System Install — use this if you already manage OpenClaw yourself on the machine. Install it first: npm install -g openclaw@latest.

Configure your model provider

After setup finishes, open Settings and configure an upstream provider:

  • CommonStack — recommended project-default path.
  • Custom Provider — OpenAI-compatible or Anthropic-compatible endpoints.

Save the provider config, fetch models if needed, and pick a default model. After that you can start chats, manage sessions, edit Soul files, and work with channels / cron / plugins / skills.

macOS Gatekeeper note
  • Public macOS releases are unnotarised; macOS may show "ClawBox is damaged and can't be opened" on first launch.
  • If you trust the release artefact: move ClawBox.app to /Applications, then xattr -dr com.apple.quarantine /Applications/ClawBox.app.
  • If you'd rather not bypass Gatekeeper, build from source.
Phase 02 · Architecture

Architecture

Three processes plus an OpenClaw daemon.

Processes [Tauri shell · Rust] src-tauri/ OS integration, window mgmt, autoupdate [React 18 SPA · Vite] src/ dev port 14200 · Tailwind · i18n (en/zh) fetch('http://127.0.0.1:13000/...') [Bun / Hono backend] internal/ route modules under internal/routes/* WebSocket RPC [OpenClaw Gateway] separate process http://127.0.0.1:18789/v1

Key boundaries

  • Tauri shell handles OS-integration only — window, updater, OS dialogs. No business logic.
  • React frontend talks to the local Bun backend on 127.0.0.1:13000. It never talks to the Gateway directly.
  • Bun backend is the bridge: per-route modules in internal/routes/, plus channel/provider/skills logic in internal/channels/, internal/providers/, internal/skills/.
  • OpenClaw Gateway is not bundled — it's a separate process managed either by ClawBox's portable runtime or by the user's system install.

Repo layout

. ├── src/ # React 18 + Vite frontend │ ├── App.tsx · main.tsx │ ├── components/ # ChatView · SettingsView · OnboardView · … │ ├── hooks/ · lib/ · services/ · store/ │ ├── locales/ # en / zh translations │ └── types/ ├── internal/ # Bun / Hono backend │ ├── index.ts · logger.ts │ ├── routes/ # agents · channels · chat · config · cron · … │ ├── channels/ · providers/ · skills/ · onboard/ │ ├── compatibility.json │ └── generated/ ├── src-tauri/ # Tauri v2 Rust shell ├── scripts/ # mock-gateway · sync-version · sign-win · … ├── docs/ │ ├── openclaw-compatibility.md │ ├── dependency-policy.md │ ├── releasing.md │ └── releases/ ├── test/ # smoke-backend.mjs ├── vite.config.ts · vitest.config.ts · tailwind.config.cjs └── package.json # version 2026.3.17
Phase 03 · Frontend views

App Views

One top-level React component per dashboard surface. All under src/components/.

StartupScreen

First launch. Probes the OpenClaw runtime, surfaces setup progress.

OnboardView

Guided setup wizard — environment mode pick (Portable / System), runtime bootstrap, provider config.

ChatView

Primary chat surface. Session list + transcript + composer. Consumes chat.ts backend route.

SoulView

Edit the agent's Soul file (persona / style / constraints). Backs onto soul.ts.

PluginsView

Plugin / channel manager. Starts, stops, configures channels registered with the Gateway.

SkillsView

Browse and configure skills. Backs onto skills.ts.

CronView

Schedule recurring agent tasks. Backs onto cron.ts.

SettingsView

Gateway URL, model provider, language, theme, telemetry toggles.

GatewayRestartBanner

Banner + hint component that catches Gateway disconnects and prompts a restart without losing state.

SuggestedQuestions

Chat-view nudges. Renders prompt suggestions.

LanguageToggle · ThemeToggle

Bound to the two i18n locales (en / zh) and a light/dark theme.

TypewriterText

Streaming-text renderer used by ChatView for assistant responses.

Subdirectories

src/components/ also contains feature folders — chat/, layout/, plugins/, sidebar/, skills/, soul/ — holding the smaller pieces that compose the top-level views above.

Phase 04 · Bun / Hono

Backend Routes

Every route module in internal/routes/ owns one domain.

ModuleResponsibility
agents.tsAgent roster + agent detail
channels.tsChannel lifecycle — start / stop / list / status
chat.tsChat send + history + session management
config.tsGateway + app config (get / patch)
cron.tsSchedule CRUD for recurring tasks
models.tsList / refresh provider models
onboard.tsWizard state + runtime probes + bootstrap
sessions.tsSession list / preview / patch / reset / delete
skills.tsSkill registry + per-skill config
soul.tsSoul file read / write
titles.tsAuto-titles for new sessions
tools.tsTool manifest + tool-call summaries

Support modules

  • internal/channels/ · internal/providers/ · internal/skills/ · internal/onboard/ — domain logic consumed by the routes.
  • internal/compatibility.json — OpenClaw version compatibility matrix.
  • internal/tool-call-summaries/ — formatting helpers that shape raw tool events into chat-view blocks.
  • internal/generated/ — build artefacts (do not edit).
Phase 05 · Setup wizard

Onboarding

The first-launch experience — ClawBox's biggest differentiator.

1 · ProbeCheck for an existing OpenClaw runtime (Portable or system).
2 · Choose modePortable (Built-in) vs System Install.
3 · Bootstrap runtimePortable: install app-managed Node.js + openclaw@latest. System: verify the user's install.
4 · Start GatewayGateway URL: http://127.0.0.1:18789/v1. Handshake = challenge/response with a local device identity.
5 · Provider configCommonStack (default) or Custom (OpenAI-/Anthropic-compatible).
6 · Model pickFetch model list, pick a default. Wizard done.

State for all six steps lives under internal/onboard/. The frontend surface is OnboardView.tsx plus StartupScreen.tsx for the probe phase.

Phase 06 · Running from source

Dev Flow

Contribute flow if you're running ClawBox from source.

1 · Install deps

npm ci

2 · Install + start OpenClaw

npm install -g openclaw@latest openclaw gateway run --dev --auth none --bind loopback --port 18789

Or point ClawBox at an existing Gateway by setting OPENCLAW_GATEWAY_URL.

3 · Start ClawBox

# Frontend (Vite :14200) + backend (Bun :13000) together: npm run dev # Or the full desktop app under Tauri: npm run tauri:dev

Mock gateway for smoke tests

scripts/mock-gateway.mjs implements the minimum RPC surface for smoke coverage without a live OpenClaw:

node scripts/mock-gateway.mjs --port 18789 npm run smoke:backend # end-to-end smoke via the mock
Phase 07 · Packaging

Build & Release

Three build steps plus platform-specific bundling.

Core build

npm run build:frontend # tsc -b && vite build npm run build:backend # node scripts/build-backend.mjs cargo check --manifest-path src-tauri/Cargo.toml

Tauri bundling

npm run tauri:build # macOS .dmg (includes clean-dmg preflight) npm run tauri:build-win # Windows x86_64 (unsigned) npm run tauri:build-win-signed # Windows signed: compile → sign → bundle → sign-installer

Repo hygiene

npm run scan:repo # repo-hygiene scanner npm run scan:public # public-mode variant npm run audit:licenses # license audit npm run audit:deps # dep audit npm run sync-version # syncs version across package.json / Cargo.toml / tauri.conf.json npm run release:version # release-version helper

Platform notes

  • macOS: Releases publish unnotarised .dmg. Users must run xattr -dr com.apple.quarantine or build from source.
  • Windows: signed installers require the sign-win.mjs + sign-win-installer.mjs scripts with valid certs.
  • Linux: source build only; no release artefact.
Phase 08 · Compatibility

OpenClaw Compatibility

ClawBox is a client. The Gateway is a separate project.

Supported baseline

ClawBox branchRecommended OpenClaw
main>= 2026.3.12

Transport expectations

  • Gateway URL shape: http://127.0.0.1:18789/v1 or equivalent.
  • Transport: WebSocket RPC upgraded from the configured HTTP URL.
  • Connect flow: challenge / response handshake with a local device identity.
  • Optional capability currently used by ClawBox chat: tool-events.

Minimum RPC surface

The included mock gateway implements the minimum RPC surface needed for repository smoke coverage:

models.list · config.get · config.patch · sessions.list sessions.preview · sessions.patch · sessions.reset · sessions.delete chat.history · chat.send

Source of truth: docs/openclaw-compatibility.md.

Support boundary

  • ClawBox bugs belong here: desktop shell, frontend, backend bridge, onboarding UI, packaging logic.
  • Pure Gateway protocol bugs, channel runtime bugs, or OpenClaw daemon behavior go to OpenClaw unless ClawBox is clearly the layer breaking the contract.
Component in the Organized Market project

Market Context

Where ClawBox sits inside the broader Organized AI portfolio.

ClawBox is the desktop surface. It doesn't define the marketplace or the agent economy — it's the thing people open on their machine to participate in what the Organized Market project describes. Pairs naturally with:

  • organized-market-arch — architecture for the surrounding marketplace + orchestration.
  • openclaw-education — OpenClaw architecture reference (the Gateway ClawBox talks to).
  • hermes-pi-harness-guide — server-side sibling; different project but same "personal AI control plane" shape.
  • duraclaw-guide — Cloudflare-edge session orchestrator; ClawBox's counterpart for multi-device / web.

When to reach for ClawBox specifically

  • You want a native desktop app with a guided setup instead of npm install -g + terminal.
  • You'd rather not run a long-lived server to use an AI agent locally.
  • You want the channel / cron / skills / plugins dashboard in one place.
  • You're on macOS or Windows; Linux users should build from source.
clawbox-guide
Organized-AI/ClawBox · v2026.3.17
Tauri v2 · Bun · React 18
clawbox-guide.pages.dev/#home