# OpenClaw OpenClaw (formerly Moltbot, originally Clawdbot) is an open-source, self-hosted personal AI assistant created by [[Peter Steinberger]]. It turns powerful language models like Claude into proactive digital coworkers capable of executing meaningful actions across devices. The Gateway runs on your own hardware (Mac, Windows, Linux, or a cloud server you control). Since OpenClaw 2.0, individual sessions can also run on a paired computer or a throwaway cloud worker, while the Gateway keeps the transcript and the credentials. The project is stewarded by the non-profit OpenClaw Foundation. Latest major version: **OpenClaw 2.0** (v2026.8.1, released August 30, 2026). See [[2026-10-03 OpenClaw 2.0 - easier setup, shared sessions, same security defaults|my OpenClaw 2.0 news note]]. > Your own personal AI assistant. Any OS. Any Platform. The lobster way. 🦞 ## Name History The project started as **Clawdbot**, with the name hinting at its origins from Claude and [[Claude Code]]. Following a trademark request from Anthropic to avoid confusion with their Claude-branded AI products, it was renamed to **Moltbot**. The project has since been renamed again to **OpenClaw**, reflecting its open-source nature while keeping the lobster theme. Dates, per Wikipedia: first published in November 2025 (under the name Warelay), renamed to Moltbot on January 27, 2026, then to OpenClaw three days later. On February 14, 2026, [[Peter Steinberger]] announced he was joining [[OpenAI]] and that a non-profit OpenClaw Foundation would take over stewardship of the project. You give natural-language commands, and it writes and executes code to get results. ## Releases and Versions OpenClaw uses calendar versioning (`vYYYY.M.N`) and ships very often: 106 releases in 230 days before 2.0, most of them a day or two apart. - **Extended-stable channel** (announced July 30, 2026): monthly long-lived lines with backported security and reliability fixes, numbered from `YYYY.M.33` (the first was 2026.6.33, based on 2026.6.11). Each line is supported until the next one is cut, for at least a month. OpenClaw also publishes a feature maturity scorecard - **OpenClaw 2.0** (v2026.8.1, August 30, 2026): the largest release so far (16,977 pull requests, 987 contributors). It started as an installer and browser app cleanup and grew into a new major version, hence the "Accidentally" in the announcement title. Headline changes: guided setup that reuses existing subscriptions, API keys and local models (careful with Claude: a Pro/Max sign-in gets billed as extra usage, see [[#Configuration]]); a rebuilt, chat-first web app; shared multiplayer cloud sessions; memory across conversations; sessions and transcripts moved to [[SQLite]]; Cron renamed Automations; Computer Use; plugin management from the UI; approvals bound to the exact request. Details in [[2026-10-03 OpenClaw 2.0 - easier setup, shared sessions, same security defaults|my news note]] - **After 2.0**: many users hit broken updates around the launch, and OpenClaw moved to atomic updates so a failed update leaves the previous version running. Point releases followed quickly (2026.8.2 on September 1, up to 2026.9.8 on October 3) - The package published as 2026.9.1-beta.1 was mislabeled: it's 2026.8.1-beta.4, and it is not newer than stable 2026.8.1 ## Key Features - **Self-hosted & privacy-first**: Runs on your own hardware with full control, data stays on your machine - **Multi-channel support**: Works through WhatsApp, Telegram, Slack, Discord, Signal, iMessage, Google Chat, Microsoft Teams, Matrix, BlueBubbles, Zalo, IRC, LINE, Nostr, Twitch, Feishu, Nextcloud Talk, Synology Chat, Tlon, Mattermost, and WebChat via unified inbox - **35+ model providers**: Anthropic, OpenAI, Google, Mistral, xAI, Groq, Ollama, vLLM, OpenRouter, Amazon Bedrock, and many more - **System access**: Direct access to filesystem, browser automation, shell commands, email, calendar - **Persistent memory**: Learns your preferences and context across sessions; since 2.0, a personal Claw can recall relevant context from the same agent's other private conversations - **Shared cloud sessions** (2.0): multiplayer sessions where several people work with the same agent context, plus sessions that run on paired computers or throwaway cloud workers ([[Crabbox]]) - **Browser and Computer Use** (2.0): signed-in browsing through an isolated managed profile or Chrome tabs you share; Computer Use on paired Macs and explicitly enabled Windows machines (Linux experimental) - **Voice support**: Always-on speech recognition and talk mode for macOS/iOS/Android via ElevenLabs - **Live Canvas**: Agent-driven visual workspace with A2UI support - **Multi-agent routing**: Host multiple isolated agents on a single gateway with separate workspaces, sessions, and auth - **ACP agents**: Spawn external coding harnesses (Claude Code, Codex, Gemini CLI, Pi, OpenCode, Kimi) as sessions - **Sub-agents**: Background agent instances for parallelized work, orchestrator patterns, and nested delegation - **Extensible**: Community skills via ClawHub or custom-built plugins - **Self-improving**: Can autonomously create and modify its own skills - **Hooks & automation**: Event-driven hooks, automations (called cron jobs before 2.0), standing orders, webhooks, polls, and heartbeat monitoring - **Context engine**: Pluggable context assembly with built-in compaction, vector search (BM25 + embeddings), and MMR re-ranking - **Nodes**: iOS/Android devices as camera, screen capture, location, and voice endpoints - **Web UIs**: Control UI, Dashboard, TUI, and WebChat interfaces. In 2.0 the Control UI was rebuilt around conversations (sidebar of conversations, the active one in the center, like ChatGPT or Claude), with files, approvals, settings and live work next to it ## Platform Support - macOS (native menu bar app with guided onboarding and Quick Chat, + node mode) - Linux (daemon via systemd; desktop companion with tray, embedded Control UI and Quick Chat) - Windows (native Windows Hub companion app, PowerShell installer, or a WSL2 Gateway) - iOS, iPadOS and Android (chat, voice, attachments, plus device node features such as camera, screen recording and notifications) - Wear OS (transcripts, replies, Talk and session controls on a paired watch) ## Installation Desktop apps are the easiest path: the Windows Hub installer and the macOS app (`.dmg`) both handle setup and can provision a local Gateway or connect to a remote one. Since 2.0, guided setup starts from the AI access you already have (Codex, ChatGPT or Claude CLI sign-ins, an API key, or [[Ollama]] / [[LM Studio]] models) and verifies that the chosen model answers before saving it. Careful with the Claude sign-in though: Anthropic bills subscription usage in third-party harnesses as "extra usage" since April 2026 (see [[#Configuration]]). Installs that would expose OpenClaw on the network without authentication are stopped. > **Upgrading to 2.0:** sessions and transcripts move to SQLite. Create a verified backup first; before downgrading to an older file-backed release, restore the archived transcripts with the current CLI. ### Installer script (recommended) ```bash # macOS / Linux / WSL2 curl -fsSL https://openclaw.ai/install.sh | bash # Windows (PowerShell) iwr -useb https://openclaw.ai/install.ps1 | iex ``` ### NPM Requires Node.js 24.16+ or 26.1+ (Node 26 recommended). ```bash npm install -g openclaw@latest --allow-scripts=openclaw # drop --allow-scripts on npm 11.15 and earlier openclaw onboard --install-daemon ``` The wizard installs a daemon service (launchd/systemd) for continuous operation. ### From Source ```bash git clone https://github.com/openclaw/openclaw.git cd openclaw pnpm install pnpm ui:build pnpm build pnpm openclaw onboard --install-daemon pnpm gateway:watch ``` Also available via Docker, Podman, Kubernetes, Nix, Ansible, and cloud providers (Hetzner, DigitalOcean, GCP, Azure, Oracle Cloud, Fly.io, Railway, Render, Northflank). Raspberry Pi supported. Experimental Bun runtime available. Legacy `clawdbot` and `moltbot` commands remain available as compatibility shims. ## Configuration Minimal setup via `~/.openclaw/openclaw.json`: ```json { "agent": { "model": "anthropic/claude-opus-4-5" } } ``` Supports Anthropic (Claude Pro/Max) and OpenAI (ChatGPT/Codex) models via OAuth subscriptions. The project recommended Anthropic Pro/Max with Opus 4.5 for long-context strength and prompt-injection resistance (early 2026 guidance; the example above dates from then too). > **Correction (2026-10-05):** the Anthropic part of that advice is outdated. Anthropic forbids using Claude Pro, Max or Team subscriptions in third-party harnesses like OpenClaw. Server-side blocks started on 2026-01-09 ("This credential is only authorized for use with Claude Code"), and since 2026-04-04 subscription OAuth used in a third-party harness is billed per token as "extra usage" instead of counting against your plan. So for Claude models in OpenClaw, plan on an Anthropic API key. The subscription still covers [[Claude Code]] and claude.ai. Since 2.0, the chat and the Models page open from the catalog OpenClaw already has, and live model discovery only runs when you open a model screen or refresh it. `/model` can change the current conversation only, or deliberately update one agent or the shared default. ## Usage Examples ### Starting the Gateway ```bash openclaw gateway --port 18789 --verbose ``` ### Sending Messages ```bash openclaw message send --to +1234567890 --message "Hello from OpenClaw" ``` ### Agent Interaction ```bash openclaw agent --message "Ship checklist" --thinking high ``` ### Chat Commands (in messaging apps) - `/status` — session overview - `/new` or `/reset` — clear context - `/think <level>` — reasoning depth (off through xhigh) - `/verbose on|off` — verbosity toggle - `/activation mention|always` — group trigger mode ### Update Channels Switch between release channels: ```bash openclaw update --channel stable|beta|dev ``` There is also a monthly **extended-stable** channel with backported fixes (see Releases and Versions above). Since 2.0, supported update paths inspect the installation before replacing it, and updates started from the Control UI show the target, ask for confirmation and report the outcome. ## License Open source under the **MIT License**. The runtime, gateway, CLI, default plugins, and skill scaffolding are all permissively licensed ; you can self-host, fork, and embed without copyleft obligations. ## Architecture The Gateway WebSocket network provides a single control plane connecting channels, clients, tools, and events at `ws://127.0.0.1:18789`. Optional Tailscale Serve/Funnel enables remote access while keeping the gateway bound to loopback. By default the gateway runs the bundled [[Pi Mono|Pi]] binary in RPC mode with per-sender sessions ; that is the out-of-the-box agent surface before you configure your own model provider, ACP backend, or sub-agents. See [[OpenClaw Gateway]] for the gateway control plane in depth. ## Sub-systems and concept notes For atomic deep-dives into individual concepts, see: - [[OpenClaw Gateway]] ; control plane, transports, multi-gateway - [[OpenClaw Multi-Agent Routing]] ; how messages reach the right agent - [[OpenClaw Sub-Agents]] ; background agent instances and orchestrator pattern - [[OpenClaw ACP Agents]] ; spawning external coding harnesses as sessions - [[OpenClaw Skills]] ; skill format, discovery, ClawHub - [[OpenClaw Hooks]] ; event-driven automation - [[OpenClaw Standing Orders]] ; persistent autonomous operating authority - [[OpenClaw Memory System]] ; daily and long-term memory, providers, search - [[OpenClaw Nodes]] ; iOS/Android device endpoints - [[OpenClaw Channels]] ; messaging surface and bindings ## Multi-Agent Routing A single gateway can host multiple isolated agents, each with separate workspaces, authentication, and sessions. Messages are deterministically routed via bindings with priority: peer match > parent peer > guild+roles > guild > team > account > channel > default agent. Each agent gets its own `~/.openclaw/agents/<agentId>/` directory with independent session stores, auth profiles, and persona files (SOUL.md, AGENTS.md). Use cases: split by personality (fast agent on WhatsApp, deep model on Telegram), per-person isolation on shared servers, family groups with restricted tools, different channel accounts routing to different agents. Setup: `openclaw agents add <name>`, configure bindings in `openclaw.json`, restart gateway, verify with `openclaw agents list --bindings`. ## ACP Agents [[Agent Client Protocol (ACP)|ACP]] sessions let OpenClaw spawn external coding harnesses as managed sessions. Supported harnesses via the `acpx` backend plugin: **[[Pi Mono|Pi]]**, **[[Claude Code]]**, **[[OpenAI Codex|Codex]]**, **OpenCode**, **[[Gemini CLI]]**, and **[[Kimi Code|Kimi]]**. Configuration: ```json { "acp": { "enabled": true, "backend": "acpx", "defaultAgent": "codex", "allowedAgents": ["pi", "claude", "codex", "opencode", "gemini", "kimi"] } } ``` Key commands: - `/acp spawn <agent>` — create and optionally bind a session (`--mode persistent|oneshot`, `--thread auto|here|off`) - `/acp status` — display backend, mode, state, capabilities - `/acp steer <msg>` — guide without replacing context - `/acp cancel` / `/acp close` — stop work or terminate session - `/acp model` / `/acp permissions` / `/acp timeout` — tune runtime - `/acp doctor` — check backend health Thread-bound sessions supported on Discord and Telegram. ACP sessions run on host runtime (not sandbox). Permissions can be preset to `approve-all`, `approve-reads` (default), or `deny-all` since no TTY exists for interactive prompts. Install: `openclaw plugins install acpx && openclaw config set plugins.entries.acpx.enabled true` ## Sub-Agents Sub-agents are background agent instances spawned from a main agent. They run in isolated sessions (`agent:<id>:subagent:<uuid>`), execute non-blocking, and announce results back to the requester's channel when complete. Spawned via the `sessions_spawn` tool or `/subagents spawn <agentId> <task>`. Key parameters: task, label, model/thinking overrides, timeout, thread binding (Discord), sandbox mode. Commands: `/subagents list`, `kill`, `log`, `info`, `send`, `steer`, `spawn`. **Orchestrator pattern**: Set `maxSpawnDepth: 2` to allow sub-agents to spawn their own children (depth-2 leaf workers). Depth-1 orchestrators get session management tools; depth-2 workers do not. Result flow: depth-2 → depth-1 → main → user. Concurrency: `maxConcurrent` (default 8), `maxChildrenPerAgent` (default 5), max nesting depth 5. Cost optimization: configure cheaper models for sub-agents via `agents.defaults.subagents.model`. Auto-archive after 60 minutes (configurable). Tool denylists configurable per sub-agent. ## Memory System Memory is stored as plain Markdown in the agent workspace: - **Daily memory**: `memory/YYYY-MM-DD.md` — append-only daily log, today's and yesterday's entries auto-loaded - **Long-term memory**: `MEMORY.md` — curated persistent information, loaded only in main/private sessions Agent tools: `memory_search` (semantic recall across indexed snippets) and `memory_get` (targeted file reads). Before context compaction, a silent agentic turn prompts the model to persist durable memories. Vector search supports multiple embedding providers (OpenAI, Gemini, Voyage, Mistral, Ollama, local GGUF) with hybrid BM25 + vector search, MMR diversity re-ranking, and temporal decay. Since 2.0: the built-in engine (a per-agent SQLite index) owns search and recall, and the QMD backend is retired (`openclaw doctor --fix` migrates it). A personal Claw can recall relevant context from the same agent's other private conversations, and the Control UI can import existing memory from Codex, [[Claude Code]] and [[Hermes Agent]]. Details in [[OpenClaw Memory System]]. ## Context Engine Controls how the model context is assembled for each run. The built-in `legacy` engine handles message storage, context assembly within token budgets, history compaction/summarization, and post-turn persistence. Pluggable via plugins: install a custom engine with `openclaw plugins install`, then set `plugins.slots.contextEngine` to the engine's ID. Custom engines can inject dynamic system prompt additions. ## Skills & Plugins Skills are directories containing a `SKILL.md` file with YAML frontmatter and instructions. They teach agents how to use tools and follow the AgentSkills-compatible format. Loaded from three locations (highest precedence first): workspace `<workspace>/skills/`, managed `~/.openclaw/skills/`, and bundled skills. Gating via requirements: required binaries, env vars, config paths, and OS restrictions. **ClawHub** (https://clawhub.com) is the public skills registry. Install: `clawhub install <skill-slug>`, update: `clawhub update --all`. Plugins extend OpenClaw with custom channels, tools, context engines, and skills. Distributed via npm packages with `openclaw.plugin.json` manifests. Install: `openclaw plugins install <name>`. ## Automation ### Hooks Event-driven handlers that fire on agent lifecycle events. Types: command events (`command:new`, `command:reset`, `command:stop`), session events (`session:compact:before/after`), agent events (`agent:bootstrap`), gateway events (`gateway:startup`), message events (`message:received`, `message:transcribed`, `message:preprocessed`, `message:sent`). Auto-discovered from `<workspace>/hooks/`, `~/.openclaw/hooks/`, and bundled hooks. Each hook has a `HOOK.md` (metadata) and `handler.ts` (async TypeScript). Distributable as npm hook packs. Built-in hooks: `session-memory` (saves context on `/new`), `bootstrap-extra-files` (injects files at bootstrap), `command-logger` (audit logging), `boot-md` (executes BOOT.md at startup). CLI: `openclaw hooks list`, `info`, `check`, `enable/disable`, `install`. ### Standing Orders Permanent operating authority for autonomous agent execution within defined boundaries. Define scope, triggers, approval gates, and escalation rules in workspace files (primarily AGENTS.md). Programs follow the Execute-Verify-Report pattern. Enforced via cron jobs for time-based triggers. ### Automations (formerly Cron Jobs) Scheduled task execution. Standing orders define *what* the agent does; automations define *when*. Also supports heartbeat monitoring and polls for event-driven automation. OpenClaw 2.0 renamed cron jobs to **Automations** in the agent tool, Control UI, CLI and docs. `openclaw automations` offers the same commands as `openclaw cron`, and the old command, settings, schedule expressions and stored jobs keep working. History now separates whether an automation ran, whether its result was delivered, and whether the request completed. ## Nodes iOS and Android devices connect as nodes to the gateway, providing: - **Camera capture**: Take photos and send to the agent - **Audio**: Voice notes, transcription, talk mode (always-on speech recognition) - **Voice wake**: Wake word detection for hands-free interaction - **Location**: Device location sharing - **Media understanding**: Image, video, and document analysis - **Screen recording**: Capture device screen for agent context ## Security Model - **Personal sessions**: Main (personal) sessions execute tools on the host with full agent access - **Group/Channel safety**: Non-main sessions can run in per-session Docker sandboxes via `sandbox.mode: non-main` - **DM policies**: Pairing mode (default) requires allowlist approval; open mode requires explicit configuration - **Sandbox restrictions**: Sandboxed sessions have denylist for browser, canvas, nodes, cron, Discord, and gateway access - **Approvals** (2.0): an approval stays attached to the exact request, command, session and person that received it; recurring automations show their standing grants, and revoking one makes the next run ask again - **Protected credentials** (2.0): secrets can reach supported destinations without entering model-visible text. The Secret Store is not encrypted at rest though; it relies on the filesystem permissions of the state directory - **Defaults**: sandboxing (Docker or Podman) and execution approvals are off by default; the baseline assumes a single trusted operator - **One trust boundary per Gateway**: multi-user and shared sessions are for people who trust each other. OpenClaw is not a multi-tenant boundary between adversarial users; run separate Gateways ("cells") with separate credentials for that ## Use Cases - **Overnight coding supervision**: Agents fix bugs and open PRs while you sleep - **Daily briefings**: Automated summaries and task lists - **Expense tracking**: Automatic categorization and reporting - **Smart home orchestration**: Control devices through natural language - **Cross-device workflows**: Coordinate actions across your devices - **Browser automation**: Form-filling and data extraction ## OpenClaw vs Claude Code | Aspect | OpenClaw | [[Claude Code]] | |--------|----------|-----------------| | Primary use | Personal assistant, orchestration | Direct coding in repos | | Interface | Messaging apps (WhatsApp, Slack, etc.), web Control UI, native apps | Terminal/CLI | | Memory | Persistent long-term memory | Session-based | | Scope | Cross-device, cross-app | Single codebase | | Best for | Automation, coordination | Focused development | Use [[Claude Code]] for the fastest direct coding loop inside a repository. Use OpenClaw when you want durable memory, cross-device access, and tool orchestration. The line is getting blurry. Since 2.0, the OpenClaw session catalog can group and open Codex, Claude Code, OpenCode and Pi sessions, and the OpenClaw team itself moved from local coding harnesses to a shared OpenClaw agent for its own development. ## Ecosystem and Adoption - **Interest**: attention peaked around March 2026 and dropped afterwards (Google Trends, cited by VentureBeat and on Hacker News). Part of the community moved to [[Hermes Agent]], [[NanoClaw]] and other harnesses - **Microsoft Autopilot** (announced September 25, 2026): Microsoft's persistent personal agent (formerly Scout) is built on OpenClaw, and Microsoft contributes policy conformance and native Windows work upstream - **OpenClaw Enterprise** (announced September 29, 2026): an open source control plane for persistent agents with multi-tenancy, hard security boundaries and governance. Started at OpenAI, donated to the Foundation, co-developed with Red Hat and NVIDIA; pilot stage, 1.0 planned for later in 2026 ## Security Recommendations ``` # SSHD config (/etc/ssh/sshd_config) PermitRootLogin no sudo sshd -t && sudo systemctl reload ssh # Brute-force protection → Auto-ban IPs after failed login attempts. sudo apt install fail2ban -y sudo systemctl enable --now fail2ban # Install Tailscale (private VPN mesh network) sudo curl -fsSL https://tailscale.com/install.sh | sh sudo tailscale up # Then connect the machine to your Tailscale account # Optional: Disable Key Expiry for that machine # SSH only via Tailscale → No more public SSH exposure. Verify Tailscale is working first! tailscale status sudo ufw allow from 100.64.0.0/10 to any port 22 proto tcp sudo ufw delete allow OpenSSH Default-deny firewall → Block everything incoming by default sudo apt install ufw -y sudo ufw default deny incoming sudo ufw default allow outgoing sudo ufw enable Web ports private too → App only accessible from your devices. sudo ufw allow from 100.64.0.0/10 to any port 443 proto tcp sudo ufw allow from 100.64.0.0/10 to any port 80 proto tcp Disable IPv6 (optional) → Reduces attack surface if unused. sudo sed -i 's/IPV6=yes/IPV6=no/' /etc/default/ufw echo "net.ipv6.conf.all.disable_ipv6 = 1" | sudo tee -a /etc/sysctl.conf sudo sysctl -p && sudo ufw reload # Install OpenClaw adduser openclaw && usermod -aG sudo openclaw && su - openclaw curl -fsSL https://openclaw.ai/install.sh | bash exec bash ... Lock to owner only → Only you can message the bot. { "dmPolicy": "allowlist", "allowFrom": ["YOUR_TELEGRAM_ID"], "groupPolicy": "allowlist" } Fix credential permissions → Don't leave secrets world-readable. chmod 700 ~/.openclaw/credentials chmod 600 .env # Run security audit → Catches issues you missed - don't skip! openclaw security audit --dee # Verify everything sudo ufw status ss -tulnp tailscale status openclaw doctor ``` ## Useful commands ``` openclaw status openclaw status --all openclaw configure openclaw doctor openclaw security audit openclaw security audit --deep openclaw security audit --fix openclaw devices list openclaw hooks list openclaw hooks enable <name> openclaw hooks disable <name> ``` ## References - Official website: https://openclaw.ai - Documentation: https://docs.openclaw.ai - Full docs index: https://docs.openclaw.ai/llms.txt - GitHub: https://github.com/openclaw/openclaw - Skills Hub: https://clawhub.com - Security: https://docs.openclaw.ai/gateway/security - ACP Agents: https://docs.openclaw.ai/tools/acp-agents - Sub-Agents: https://docs.openclaw.ai/tools/subagents - Multi-Agent Routing: https://docs.openclaw.ai/concepts/multi-agent - Memory: https://docs.openclaw.ai/concepts/memory - Skills: https://docs.openclaw.ai/tools/skills - Hooks: https://docs.openclaw.ai/automation/hooks - Standing Orders: https://docs.openclaw.ai/automation/standing-orders - Context Engine: https://docs.openclaw.ai/concepts/context-engine - Plugins: https://docs.openclaw.ai/plugins/building-plugins - Community Discord: https://discord.com/invite/clawd - More skills: https://github.com/VoltAgent/awesome-openclaw-skills - Support on [[Cloudflare]]: https://blog.cloudflare.com/moltworker-self-hosted-ai-agent/ - Blog: https://openclaw.ai/blog - Release notes: https://docs.openclaw.ai/releases - OpenClaw 2.0 announcement: https://openclaw.ai/blog/openclaw-2-accidentally - OpenClaw 2.0 release notes (v2026.8.1): https://docs.openclaw.ai/releases/2026.8.1 - Extended-stable releases: https://openclaw.ai/blog/extended-stable-releases-and-maturity-scorecards - Atomic updates after 2.0: https://openclaw.ai/blog/shipping-openclaw-updates-that-dont-break - Install: https://docs.openclaw.ai/install - Cloud sessions: https://docs.openclaw.ai/gateway/cloud-sessions - Microsoft Autopilot: https://openclaw.ai/blog/microsoft-autopilot-openclaw - OpenClaw Enterprise: https://openclaw.ai/blog/openclaw-enterprise - Wikipedia: https://en.wikipedia.org/wiki/OpenClaw - The Register on 2.0: https://www.theregister.com/ai-and-ml/2026/08/31/openclaw-20-pours-glitter-on-slow-burning-security-dumpster-fire/5293492 - VentureBeat on 2.0: https://venturebeat.com/technology/openclaw-2-0-is-here-what-it-means-for-enterprises - Anthropic bans subscription auth in third-party tools (AlternativeTo): https://alternativeto.net/news/2026/2/anthropic-officially-bans-using-subscription-authentication-for-third-party-claude-use - Anthropic bans Claude subscription OAuth in third-party apps (WinBuzzer): https://winbuzzer.com/2026/02/19/anthropic-bans-claude-subscription-oauth-in-third-party-apps-xcxwbn/ - Extra usage billing for third-party harnesses (claude-mem issue #1826): https://github.com/thedotmack/claude-mem/issues/1826 ## Videos - https://www.ted.com/talks/peter_steinberger_how_i_created_openclaw_the_breakthrough_ai_agent - https://www.youtube.com/watch?v=zgNvts_2TUE ## Related - [[2026-10-03 OpenClaw 2.0 - easier setup, shared sessions, same security defaults]] - [[AI Agents]] - [[Claude Code]] - [[OpenClaude]] - [[Claude]] - [[Peter Steinberger]] - [[OpenClaw VPS Configuration Guide]] - [[How to Connect OpenClaw to Chrome via Tailscale (Article)]] - [[Pi Mono]] - [[Scrapling]] - [[Kimi K2.6]] - [[Crabbox]] — OpenClaw's remote testbox for running tests/commands on ephemeral cloud machines - [[qm (Y Combinator)]] — YC's org-scale harness, positioned as "customizable like Hermes or OpenClaw, but for a whole company" - [[MiniMax Agent]]