What is Cloudbot? How the First Local Agent Stack Turns Conversations into True Automation

Cloudbot is an open source AI personal assistant that you run on your hardware. It connects large language models from providers like Anthropic and OpenAI to real tools like messaging apps, files, shell, browser and smart home devices, while keeping the orchestration layer under your control.

The interesting part isn't that Cloudbot chats. That project sends the concrete structure to the first local agents, and a typed workflow engine called Lobster that turns model calls into decision pipelines.

Architecture: Gateway, Nodes and Capabilities

At the heart of Cloudbot is the Gateway process. The Gateway exposes the WebSocket control plane on ws://127.0.0.1:18789 and an HTTP interface for the UI control area and web chat.

Your messages from WhatsApp, Telegram, Signal, Slack, Discord, iMessage and other channels are delivered to Gateway. The Gateway decides which agent should handle the message, which tools to call, and which provider model to use. It then sends a reply via the same channel.

Runtime is divided into several important concepts:

• The gate: Routing, model calls, tool request, times, presence and scheduling.
• Nodes: Processes that give Clawdbot access to local resources such as the file system, default browser, microphone, camera or platform-specific APIs on macOS, Windows, Linux, iOS and Android.
• Channels: Integration of chat systems such as WhatsApp, Telegram, Discord, Slack, Signal, Microsoft Groups, Matrix, Zalo and more. These are configured as channel backends attached to the Gateway.
• Capabilities and plugins: Tools the agent can call, defined in a general way SKILL.md format and distributed through CloudHub.

This separation allows you to run the Gateway on a five-dollar virtual server or a spare machine at home, while keeping the heavy model computing for remote APIs or local back-end models when needed.

Skills and SKILL.md standard

Cloudbot uses an open skill format defined in it SKILL.md. A skill is defined in Markdown with a subheading and an ordered procedure. For example, the deploy capability may specify steps such as checking the git status, running the test and deploying only after success.

---
name: deploy-production
description: Deploy the current branch to production. Use only after tests pass.
disable-model-invocation: true
---
1. Check git status ensuring clean working directory.
2. Run `npm test`
3. If tests pass, run `npm run deploy`

Gateway reads these definitions and exposes them to agents as tools with transparent capabilities and security restrictions. Skills are published on CloudHub and can be embedded or integrated into larger workflows.

This means that functional runbooks can go from ad-hoc wiki pages to machine-readable capabilities, while still being readable as text.

Lobster: A typed runtime for agents

Lobster is a runtime that powers Local Lobster and many of Cloudbot's advanced automations. It is defined as a typed workflow shell that allows Cloudbot to run a multi-step tool sequence as a single deterministic task with specific enabled gates.

Instead of having the model call multiple instruments in a loop, Lobster moves the orchestration to a domain-specific instance:

• Pipes are defined as JSON or YAML, or as a shell concatenated as a pipe thread.
• The step-by-step exchange typed JSON data, not unstructured text.
• The runtime enforces timeout, output limits and sandbox policies.
• The workflow can stop on negative results and start again later with resumeToken.

A simple inbox sequence looks like this:

name: inbox-triage
steps:
  - id: collect
    command: inbox list --json
  - id: categorize
    command: inbox categorize --json
    stdin: $collect.stdout
  - id: approve
    command: inbox apply --approve
    stdin: $categorize.stdout
    approval: required
  - id: execute
    command: inbox apply --execute
    stdin: $categorize.stdout
    condition: $approve.approved

Cloudbot treats this file as a skill. When you ask it to clean up your inbox, it calls a single Lobster pipeline instead of developing multiple tool calls. The model is decisive when to use a pipe and which parameters, but the pipe itself is always deterministic and readable.

Local Lobster is a reference agent that uses Lobster to drive local workflows and is described in the coverage as an open source agent that redefines personal AI by matching initial local workflows to active behaviors.

The first local behavior that works

A key reason why Cloudbot is trending and getting noticed in the X and developer communities is that it behaves like an operator, not just a chat window.

Because the Gateway can run scheduled tasks and track status across sessions, common patterns include:

• Daily information summarizing calendars, tasks and important mail.
• Occasional repetitions such as job summaries posted weekly.
• Monitors who watch the situation, then send you a message first on your favorite channel.
• File and cache automation that works locally but is configured in natural language.

All of this works with routing and policy tools on your machine or server. Model calls still go to providers like Anthropic, OpenAI, Google, xAI or local backends, but the assistant's logic, memory and integration are under your control.

Installation and developer workflow

The project provides a one-line installer that downloads the script from clawd.bot and bootstraps Node, Gateway and core components. For more control, you can install with npm or compile a TypeScript repository and build with pnpm.

General steps:

curl -fsSL  | bash

# or

npm i -g clawdbot
clawdbot onboard

After boarding you connect a channel like Telegram or WhatsApp, choose a model provider and enable the capabilities. From there you can write your own SKILL.md files, create Lobster workflows and display them through chat, web chat or a macOS companion app.

Some Examples