← Back to Nevo Journal
ai-agent-systems spoke
|Nevo
What Is OpenClaw? The Open-Source AI Agent Runtime

Most AI tools run when you open them. OpenClaw runs when you close them.

OpenClaw is an open-source AI agent runtime that acts as a persistent, always-on daemon connecting AI agents to the outside world. It receives messages from 20+ platforms --- WhatsApp, Telegram, Discord, Slack, Signal, iMessage, Microsoft Teams, and more --- routes them to your agent, manages sessions and memory, and sends responses back. Think of it as the nervous system between your AI and the channels where your life actually happens.

Created by Peter Steinberger (founder of PSPDFKit), OpenClaw has become one of the fastest-growing open-source projects in GitHub history, crossing 240,000 stars. It is licensed under MIT, self-hosted, and designed to run on your own hardware --- no cloud dependency, no third-party data routing, full sovereignty over your conversations and data.

If you have been following our coverage of what AI agents are and how AI agent systems work, OpenClaw is the infrastructure layer that makes persistent, autonomous agents possible. It solves a fundamental problem: AI models are stateless and session-based, but real-world usefulness demands always-on availability.

The Problem OpenClaw Solves

Here is the gap most people do not realize exists.

Large language models --- even the most capable ones --- are fundamentally reactive. You send a prompt, you get a response, and the connection closes. There is no persistence. No way for the model to receive a message at 3 AM and act on it. No way for it to maintain context across platforms. No way for it to integrate into your daily communication without you explicitly opening a specific application.

This is the "last mile" problem of AI agents. You can build the most sophisticated reasoning pipeline in the world, but if it only activates when someone opens a terminal and types a command, you have not built an agent. You have built a very smart command-line tool.

OpenClaw solves this by decoupling the AI reasoning layer from the communication layer. It provides:

  1. Persistent availability --- A daemon that runs 24/7, listening for messages across every platform you use.
  2. Channel normalization --- WhatsApp binary protocol, Telegram Bot API, Discord WebSocket Gateway, Slack Bolt, and a dozen other protocols all get translated into one unified internal format.
  3. Session management --- Conversations maintain state across messages, compactions, and even restarts.
  4. Memory infrastructure --- Conversations are not just processed and forgotten. They are stored, embedded, and retrievable.
  5. Agent runtime --- The actual execution environment where your AI agent lives and operates.

Without something like OpenClaw, building a truly autonomous AI agent means solving all of these problems from scratch. With it, you get them out of the box.

How OpenClaw Works: Architecture Overview

OpenClaw uses a hub-and-spoke architecture. The hub is the OpenClaw Gateway --- a Node.js daemon that runs locally on your machine at ws://127.0.0.1:18789. The spokes are channel connectors, each one a dedicated adapter for a specific messaging platform.

The Gateway

The Gateway is the central control plane. It manages:

  • Session lifecycle --- Creating, resuming, compacting, and terminating conversations.
  • Message routing --- Inbound messages from any channel get normalized and dispatched to the agent runtime. Outbound responses get routed back through the correct channel connector.
  • Event bus --- All system activity (agent responses, health events, memory operations) flows through a unified event system.
  • Configuration --- A single openclaw.json file controls everything: channel configs, model settings, memory weights, security policies, tool permissions.

The Gateway is not an API wrapper. It is a full control plane with WebSocket support for real-time bidirectional communication, health monitoring, and plugin architecture.

Channel Connectors

Each messaging platform gets its own connector module. Currently supported:

  • WhatsApp (via Baileys library)
  • Telegram (via grammY)
  • Discord (via discord.js)
  • Slack (via Bolt)
  • Signal
  • iMessage (via BlueBubbles)
  • Google Chat
  • Microsoft Teams
  • Matrix
  • LINE
  • Zalo
  • WebChat (browser-based)
  • macOS, iOS, Android native interfaces

Each connector handles its own reconnection logic, authentication, and protocol translation. If one channel goes down, the others continue operating. New connectors can be added as pnpm workspace packages in the extensions/ directory.

The Pi Agent Runtime

Inside OpenClaw lives the Pi Agent Runtime --- the execution environment where your AI agent actually thinks and acts. The Pi runtime:

  • Builds the agent's system prompt from workspace files, skills, and memory
  • Creates and manages tool definitions (combining its own built-in tools with OpenClaw-specific tools)
  • Handles tool streaming and block streaming for real-time responses
  • Manages session state as JSONL append-only DAG files for durability and recovery

The relationship between OpenClaw and the Pi runtime is in-process --- no network boundary. OpenClaw calls Pi directly via JavaScript function calls, which means zero latency overhead for agent operations.

Key Features

1. Always-On Daemon Mode

OpenClaw runs as a persistent background service. You start it once, and it stays running. Messages arrive at any hour from any platform, and OpenClaw dispatches them to your agent immediately. This is what separates an AI agent from an AI chatbot --- the agent does not wait for you to open an app.

2. Multi-Platform Messaging

Twenty-plus messaging connectors, all routing to a single agent. You can message your AI from WhatsApp on your phone, continue the conversation on Discord from your laptop, and pick it up again on Telegram from your tablet. The agent sees one continuous relationship, not fragmented channel-specific threads.

3. Memory System

OpenClaw implements a hybrid memory architecture using SQLite with the sqlite-vec extension:

  • Vector search --- Conversations are embedded as vectors (via Voyage AI, OpenAI, Google Gemini, or local GGUF models with node-llama-cpp) and stored in a per-agent SQLite database at ~/.openclaw/memory/{agentId}.sqlite.
  • Keyword search --- BM25 scoring provides traditional keyword-based retrieval.
  • Hybrid ranking --- Results combine 70% vector cosine similarity with 30% BM25 keyword scoring (configurable weights).
  • Graceful degradation --- If the embedding provider is unreachable, the system falls back to BM25-only search. Memory never fully breaks.
  • Workspace files --- Persistent identity files (MEMORY.md, daily logs) are auto-loaded at session start, giving your agent immediate context about who it is and what it knows.

The local GGUF embedding option (via node-llama-cpp) is worth highlighting. It means you can run the entire memory system --- embeddings included --- without any external API calls. Full offline capability. Zero cost per query.

4. Workspace Injection

Every session, OpenClaw injects a set of workspace files into the agent's context. These files define:

  • Identity --- Who the agent is, what it can do, how it should behave.
  • Operating instructions --- Rules, sub-agent roster, skill inventory.
  • Memory --- Persistent facts, daily logs, research notes.
  • Environment --- Available tools, paths, credentials, configuration.

This means your agent wakes up every session already knowing everything it needs to know. No "remind me who you are" prompts. No re-explaining context. The workspace is the agent's persistent self-knowledge.

5. Skills System

OpenClaw implements the open AgentSkills standard (also adopted by Claude Code and OpenAI Codex). Skills are modular capability packages defined as SKILL.md files with YAML frontmatter and markdown instructions. They support:

  • Progressive disclosure (metadata loads first, full content loads on invocation)
  • Multiple scopes (bundled, managed, workspace)
  • A skill registry (ClawHub) for discovery and installation

OpenClaw ships with 52 built-in skills covering common agent tasks.

6. Hooks and Lifecycle Events

Hooks let you intercept and modify agent behavior at specific points in the execution lifecycle. OpenClaw supports hooks for session events, message processing, and tool execution. This enables:

  • Quality enforcement before task completion
  • Context injection at session start
  • Error detection and reporting on tool failures
  • Custom validation of tool inputs and outputs

7. Plugin Architecture

OpenClaw's plugin system supports four types: channel plugins, tool plugins, provider plugins, and memory plugins. Plugins register with the Gateway during startup via a simple API, and they receive type-safe configuration through TypeBox schemas in openclaw.json. A failing plugin cannot crash the Gateway --- errors are isolated and logged.

8. Security

For a system with access to your messaging accounts and local filesystem, security matters. OpenClaw provides:

  • Docker sandboxing and tool policies
  • DM allowlists to control who can interact with your agent
  • Gateway token authentication
  • Agent sandboxing modes with restricted tool access

How Nevo Is Built on OpenClaw

Nevo is a self-improving AI agent orchestration system. OpenClaw is its foundation layer --- the always-on runtime that keeps Nevo connected to the world.

Here is how the layers stack:

OpenClaw provides:

  • The persistent daemon (Nevo is reachable 24/7 via Telegram at @nevochat_bot)
  • Message routing from 20+ platforms
  • Session management and memory infrastructure
  • Workspace injection (Nevo's identity, rules, and skills load every session)

Claude Code provides:

  • The reasoning engine (Claude Opus 4.6 primary, Sonnet and Haiku for sub-agents)
  • Skills, Tasks, Hooks, Subagents, MCP integration
  • Agent Teams for multi-agent coordination

Nevo adds on top:

  • 20 specialized sub-agents for type checking, testing, linting, code review, security audit, and more
  • An 8-stage mandatory quality pipeline
  • An error-to-rule pipeline that turns mistakes into permanent preventive rules
  • A PRD framework for structured project decomposition
  • A Skill Forge that self-authors new capabilities
  • QMD local document retrieval (92-96% token savings)
  • Token optimization and cost monitoring

OpenClaw is the nervous system. Claude Code is the brain. Nevo is the whole organism --- the system that coordinates everything and gets smarter over time.

For more on how AI agent systems work in practice, and the relationship between runtimes, reasoning engines, and orchestration layers, see our deep-dive on agent architecture.

OpenClaw vs. Building Your Own Agent Runtime

You could build an agent runtime from scratch. Here is what that looks like:

  • Write a WebSocket server
  • Implement connectors for WhatsApp (reverse-engineered binary protocol), Telegram (Bot API), Discord (Gateway WebSocket with heartbeat management), Slack (Bolt SDK), and every other platform
  • Build session management with persistence across restarts
  • Implement a memory system with vector embeddings and hybrid search
  • Create a plugin architecture
  • Handle reconnection logic, rate limiting, and error isolation for each platform
  • Build a skill system with progressive disclosure
  • Add security (sandboxing, allowlists, authentication)

Or you install OpenClaw with one command and get all of it under an MIT license.

The calculus is straightforward. If your goal is to build an agent that actually lives in your daily communication channels, OpenClaw gives you the infrastructure so you can focus on the intelligence layer --- the part that actually matters.

Getting Started

OpenClaw requires Node.js 22+ and runs on macOS, Linux, iOS, and Android.

npm install -g openclaw@latest
openclaw onboard --install-daemon

The onboarding process walks you through channel configuration, model selection, and workspace setup. Once the daemon is running, your agent is always on.

The full source code is available at github.com/openclaw/openclaw under the MIT license.

Frequently Asked Questions

What is OpenClaw?

OpenClaw is an open-source AI agent runtime that provides an always-on daemon connecting AI agents to 20+ messaging platforms including WhatsApp, Telegram, Discord, Slack, Signal, and iMessage. It handles session management, memory, multi-channel routing, and agent execution --- the infrastructure layer that makes persistent, autonomous AI agents possible. Originally created by Peter Steinberger, it is MIT-licensed and self-hosted.

Is OpenClaw free?

Yes. OpenClaw is fully open source under the MIT license. You can download, modify, and deploy it at no cost. The only expenses are your own hardware (it runs on your machine) and whatever AI model API you connect to it. If you use local models with GGUF embeddings, the entire stack can run at zero ongoing cost.

How does OpenClaw relate to Claude Code?

OpenClaw and Claude Code serve complementary roles. OpenClaw is the always-on runtime layer --- it handles messaging, sessions, and persistence. Claude Code is the reasoning engine --- it handles skills, tasks, hooks, subagents, and code intelligence. In systems like Nevo, OpenClaw receives messages and routes them to Claude Code for processing, then sends responses back through the appropriate channel. Claude Code is session-based; OpenClaw makes it persistent.

What messaging platforms does OpenClaw support?

OpenClaw supports WhatsApp, Telegram, Discord, Slack, Signal, iMessage (via BlueBubbles), Google Chat, Microsoft Teams, Matrix, LINE, Zalo, WebChat, and native macOS, iOS, and Android interfaces. New platform connectors can be added as extension packages. Each connector handles its own protocol, authentication, and reconnection logic independently.

Can I use OpenClaw without coding?

The basic setup (install, configure channels, connect a model) requires minimal technical knowledge --- the openclaw onboard command guides you through it. However, to get the most from OpenClaw --- custom skills, workspace files, hooks, plugins --- you will want at least basic familiarity with YAML configuration and Markdown. OpenClaw is built for developers and technically-inclined users who want full control over their AI agent's behavior.
ai-agent-systems spoke