ClawdBot: Your AI Assistant, the Lobster Way 🦞

1 What Is ClawdBot?

If you have ever wished that Siri, Alexa, or Google Assistant could actually do things — send emails on your behalf, negotiate car prices, check you in for flights, or fix code while you sleep — then ClawdBot is the project that delivers on that promise. Unlike cloud-locked assistants that forget everything between sessions, ClawdBot runs on your own hardware, keeps persistent memory of every conversation, and connects to the chat apps you already use.

According to the official ClawdBot website, it is described as "Your own personal AI assistant. Any OS. Any Platform. The lobster way." The project is available on GitHub under the MIT license, making it completely free to use, modify, and extend.

What makes ClawdBot fundamentally different from ChatGPT or Claude conversations in a browser is its agentic nature. ClawdBot is not just a chatbot — it is an autonomous agent that can:

• Take real-world actions: Browse websites, fill out forms, send emails, and interact with web services
• Remember everything: Persistent memory across sessions means it knows your preferences, past conversations, and important context
• Reach out proactively: Morning briefings, reminders, and alerts when something you care about happens — it messages you first
• Run 24/7: As a background service on your machine or server, it is always available
• Protect your privacy: All data stays on your hardware; nothing is stored in someone else's cloud

2 History & Origin Story

The Creator: Peter Steinberger

ClawdBot was created by Peter Steinberger, an Austrian engineer widely known in the developer community. Steinberger founded PSPDFKit in 2011 — a document processing SDK used by nearly one billion people through apps that integrated it. The name "PSPDFKit" was a reference to Peter Steinberger's initials combined with "PDF" (the company's focus) and "Kit" (referencing iOS SDK conventions).

In 2021, PSPDFKit (now rebranded as Nutrient) raised €100 million from Insight Partners, and Steinberger made a successful exit. After stepping away from day-to-day operations, he described himself as "coming back from retirement to mess with AI."

From Personal Project to Phenomenon

ClawdBot emerged in late 2025 as Steinberger's personal AI assistant project. He built the initial version around an AI character named Clawd — a playful space lobster that became the project's mascot and brand identity. The name "Clawd" is not coincidentally similar to "Claude" — Steinberger used Anthropic's Claude models heavily during development and drew naming inspiration from them.

Steinberger's blog post "Claude Code is my computer" went viral, showing how he had built a personal AI assistant that could execute real-world tasks through chat. This generated massive community interest. What started as a personal tool rapidly transformed into an open-source project when Steinberger released the code on GitHub.

Explosive Growth

When ClawdBot launched on GitHub in January 2026, the response was immediate and overwhelming. Within weeks:

• The repository accumulated over 42,800 GitHub stars with 4,900+ forks
• Thousands of developers joined the Discord community, now exceeding 8,900 members
• Over 50 contributors began submitting skills, integrations, and bug fixes
• Viral demonstrations on YouTube and tech forums drove mainstream attention

3 Key Features & Capabilities

ClawdBot is far more than a simple chatbot interface. According to the official documentation, the platform offers a rich set of capabilities that distinguish it from every other AI assistant on the market.

Multi-Channel Messaging

ClawdBot connects to virtually every messaging platform through dedicated protocol integrations — not screen scraping or fragile workarounds. WhatsApp uses the Baileys protocol, Telegram uses the Bot API via grammY, Discord uses discord.js, and Slack uses Bolt. This means reliable, native-feeling interactions on each platform.

Persistent Memory

Unlike ChatGPT or Claude conversations that start fresh each time, ClawdBot maintains a continuous memory across all interactions. It remembers your preferences, past conversations, important dates, and contextual details. If you mention your spouse's birthday in March, ClawdBot will remind you when the time comes.

Proactive Outreach

This is the feature that consistently surprises new users. ClawdBot does not wait for you to ask — it can proactively send you messages. Configure morning briefings, flight check-in reminders, weather alerts, or notifications when something you are monitoring changes. As one Medium article put it: "The AI assistant that actually messages you first."

Browser Automation

ClawdBot runs a dedicated Chrome/Chromium instance that it controls programmatically. It can navigate websites, fill out forms, take screenshots, upload files, and manage browser profiles — all autonomously. This enables tasks like booking appointments, comparing prices across websites, or submitting applications.

Voice Integration

Through ElevenLabs integration, ClawdBot can speak and listen on macOS, iOS, and Android. Wake word detection and natural voice responses make it function as a voice assistant, not just a text-based one.

Canvas Visual Workspace

ClawdBot can render a live Canvas surface that you can see and control. This visual workspace enables interactive diagrams, dashboards, or any visual content the AI needs to share with you in real time.

Cron Jobs & Webhooks

Schedule recurring tasks and respond to external events. Combined with the Lobster workflow engine (covered in Section 10), this enables sophisticated automation pipelines that run reliably without manual intervention.

Skills & ClawdHub

The modular skills system allows community-built extensions. ClawdHub is a skill registry where agents can search for and install new capabilities automatically. The system can even program its own extensions when a user requests a capability it does not have yet.

4 Architecture Overview

ClawdBot follows a Gateway-centric architecture built on a loopback-first network model. Understanding this architecture helps you configure, troubleshoot, and extend the platform effectively.

Key Architecture Concepts

• Gateway: A single long-running process (clawdbot gateway) that owns all channel connections and manages the WebSocket control plane. It defaults to ws://127.0.0.1:18789.
• Agent Routing: Multiple provider accounts can be routed to isolated agents with per-agent sessions and workspace management. This enables running different LLM models for different use cases.
• Sessions: Direct chats collapse into a shared main session, while group chats remain isolated with optional mention-based activation rules.
• Sandboxing: Non-main sessions can be sandboxed in Docker containers by default, providing security isolation for multi-user scenarios.
• Loopback-First: The gateway binds to localhost by default. Remote access is achieved through SSH tunneling or Tailnet/VPN, keeping the attack surface minimal.

5 Supported Channels

One of ClawdBot's most compelling features is its ability to meet you where you already communicate. Rather than forcing you into a new app or interface, it integrates with the messaging platforms your contacts and colleagues already use.

Additional channels include Google Chat (Chat API), BlueBubbles (iMessage bridge for non-Mac), Zalo, and Zalo Personal. The extension architecture means the community can add new channels without modifying the core codebase.

6 Installation & Setup

By the end of this section, you will have a fully working ClawdBot instance running on your computer, responding to your messages via the terminal. No prior experience with AI tools or servers is needed — just follow each step. The official getting started guide covers advanced platform-specific details.

Before You Begin: What You'll Need

ClawdBot is software that runs on your computer (not in the cloud). To power the AI brain behind it, you need an account with an AI provider. Here's everything required:

Option 1: Quick Install (Recommended)

# Linux / macOS (paste this into Terminal)
curl -fsSL https://clawd.bot/install.sh | bash

# Windows (paste this into PowerShell, before switching to WSL)
iwr -useb https://clawd.bot/install.ps1 | iex

# Alternative: if you already have Node.js, install via npm
npm install -g clawdbot@latest

# Start the setup wizard (it also installs ClawdBot as a background service)
clawdbot onboard --install-daemon

The wizard will ask you to:

• Choose gateway type: Select "Local" for your first installation (this runs everything on your computer)
• Enter your API key: Paste the Anthropic API key you created earlier
• Pick a model: Choose anthropic/claude-sonnet-4-5 for a good balance of speed and quality, or anthropic/claude-opus-4-5 for the best quality
• Select chat channels: Pick which messaging apps you want to connect (WhatsApp, Telegram, Discord, etc.). You can always add more later
• Set DM security: Keep the default "pairing" mode — this prevents strangers from using your bot

# Check if the gateway (ClawdBot's brain) is running
clawdbot gateway status

# Run a full health check (flags any configuration issues)
clawdbot doctor

# See a complete status report (great for debugging)
clawdbot status --all

If everything is green, congratulations — ClawdBot is alive! You should also be able to open the ClawdBot Dashboard in your browser at http://127.0.0.1:18789/.

Option 2: Install from Source (For Developers)

If you want to customize ClawdBot or contribute to the project, build from source:

# Clone the repository
git clone https://github.com/clawdbot/clawdbot.git
cd clawdbot

# Install dependencies and build
pnpm install
pnpm ui:build
pnpm build

# Run the setup wizard
clawdbot onboard --install-daemon

# Or start the gateway manually (useful for development)
node dist/entry.js gateway --port 18789 --verbose

Option 3: Docker

If you're familiar with Docker, this is the fastest way to get a containerized instance:

# Clone repo and run the Docker setup script
git clone https://github.com/clawdbot/clawdbot.git
cd clawdbot
./docker-setup.sh

The Docker script builds the image, runs the onboarding wizard inside the container, and starts the gateway automatically.

Your First Conversation (Hello World)

Your ClawdBot is installed and running. Now let's make sure it actually works by having your first conversation — the "Hello World" of ClawdBot.

# Send a simple message to your bot
clawdbot agent --message "Hello! What can you do for me?"

ClawdBot should respond within a few seconds with something like: "Hello! I'm Clawd, your personal AI assistant. I can help you with managing emails, browsing the web, controlling smart devices, and much more. What would you like to do?"

# Ask ClawdBot about today's weather (tests web search skill)
clawdbot agent --message "What's the weather like today?"

# Ask it to list files in your home directory (tests terminal skill)
clawdbot agent --message "List the files in my home directory"

# Ask it what time it is (tests basic system access)
clawdbot agent --message "What's the current date and time?"

# Or send a test message from the CLI to your phone number
clawdbot message send --target +1XXXXXXXXXX --message "Hello from ClawdBot!"

Replace +1XXXXXXXXXX with your actual phone number (including country code). You should receive this message in your connected messaging app.

7 WhatsApp Integration Guide

WhatsApp is the most popular channel for ClawdBot users — and for good reason. You can message your AI assistant from anywhere, just like texting a friend. This section walks you through connecting WhatsApp step by step. For the full reference, see the official WhatsApp documentation.

What You'll Need

Step-by-Step: Connect WhatsApp

# Add WhatsApp as a channel (if not done during onboarding)
clawdbot configure --section channels

When prompted, select WhatsApp from the channel list and enter your phone number in international format (e.g., +14155551234).

# Generate a QR code in your terminal
clawdbot channels login

A QR code will appear in your terminal. Now, on your phone:

• Open WhatsApp on your phone
• Go to Settings (tap the three dots on Android, or Settings tab on iOS)
• Tap Linked Devices
• Tap Link a Device
• Point your phone's camera at the QR code in your terminal

Once scanned, the terminal should confirm: "WhatsApp linked successfully." ClawdBot is now connected to your WhatsApp account.

# Restart the gateway to activate WhatsApp
clawdbot gateway restart

# Verify WhatsApp is connected
clawdbot gateway status

How pairing works: When an unknown number messages your bot, ClawdBot sends them a 6-digit code (and ignores their message). You approve or reject that code from the terminal:

# See all pending pairing requests
clawdbot pairing list whatsapp

# Approve a contact (replace 123456 with the actual code)
clawdbot pairing approve whatsapp 123456

# Reject a contact
clawdbot pairing reject whatsapp 123456

Once approved, that contact can message your bot freely from then on. Pairing codes expire after 1 hour.

Try sending: "Hello ClawdBot, what can you do?"

You should receive a reply within a few seconds. If you used a separate number for ClawdBot, message that number from your personal WhatsApp. If you used your personal number, message yourself (enable selfChatMode — see below).

# Alternative: send a test message from the CLI
clawdbot message send --target +1XXXXXXXXXX --message "Hello from ClawdBot!"

Using Your Personal Number (Self-Chat Mode)

If you're using your own phone number (not a separate one), enable self-chat mode. This lets you message yourself to talk to ClawdBot, keeping conversations private and avoiding accidental messages to contacts.

// In your ClawdBot config (~/.clawdbot/config.json)
{
  "channels": {
    "whatsapp": {
      "selfChatMode": true,
      "dmPolicy": "allowlist",
      "allowFrom": ["+1XXXXXXXXXX"]
    }
  }
}

With selfChatMode enabled, open your own contact in WhatsApp (or use the "Message Yourself" feature) and type your message. ClawdBot will reply in the same chat.

WhatsApp Limits & Tips

WhatsApp Troubleshooting

8 Security & Trust: Can You Trust ClawdBot on Your Hardware?

This is the question every new user asks — and rightly so. ClawdBot runs on your computer, can execute terminal commands, read your files, browse the web, and send messages on your behalf. That's a lot of power to hand to an AI. Here's an honest, balanced look at the risks and protections, based on the official security documentation and community experience.

The Short Answer

Yes, you can trust ClawdBot — but only if you configure it properly. Out of the box, ClawdBot ships with sensible defaults (loopback networking, DM pairing, no public access). However, its power comes from having real access to your system, which means misconfiguration can have real consequences. Think of it like giving someone the keys to your house: you need to make sure you're giving them to the right person, and that you've locked the rooms you don't want entered.

Why ClawdBot Is Trustworthy

The Real Risks (And How to Mitigate Them)

No tool with real system access is risk-free. Here are the genuine concerns and what to do about them:

ClawdBot's Trust Hierarchy

ClawdBot implements a five-level trust model that determines what each user category can do:

Security Hardening Checklist

Follow this checklist to lock down your ClawdBot installation:

# 1. Run the security audit
clawdbot security audit --deep

# 2. Auto-fix common issues
clawdbot security audit --fix

# 3. Verify file permissions (credentials should be owner-only)
chmod 700 ~/.clawdbot
chmod 600 ~/.clawdbot/clawdbot.json
chmod 600 ~/.clawdbot/credentials/**/*.json

# 4. Check for misconfigured DM policies
clawdbot doctor

# 5. Set minimal mDNS discovery (don't broadcast file paths)
# In ~/.clawdbot/clawdbot.json → discovery.mdns.mode: "minimal"

Recommended Secure Configuration

Copy this baseline config to ~/.clawdbot/clawdbot.json for a hardened setup:

{
  "gateway": {
    "mode": "local",
    "bind": "loopback",
    "port": 18789,
    "auth": {
      "mode": "token",
      "token": "your-long-random-token-here"
    }
  },
  "channels": {
    "whatsapp": {
      "dmPolicy": "pairing",
      "groups": { "*": { "requireMention": true } }
    }
  },
  "agents": {
    "defaults": {
      "sandbox": {
        "mode": "non-main",
        "workspaceAccess": "ro"
      }
    }
  },
  "discovery": { "mdns": { "mode": "minimal" } },
  "logging": { "redactSensitive": "tools" }
}

Key settings explained:

• bind: "loopback" — Only allows local connections (default). Never change to "lan" unless behind a firewall.
• dmPolicy: "pairing" — Unknown contacts must be manually approved before they can use the bot.
• requireMention: true — Bot only responds in group chats when explicitly @mentioned.
• sandbox.mode: "non-main" — Non-owner sessions run inside isolated Docker containers.
• workspaceAccess: "ro" — Sandboxed agents get read-only filesystem access.
• redactSensitive: "tools" — Automatically redacts sensitive data from logs.

If Something Goes Wrong: Incident Response

If you suspect unauthorized access or something went sideways:

# Step 1: Stop the gateway immediately
clawdbot gateway stop

# Step 2: Lock down network access
# Set gateway.bind: "loopback" in config

# Step 3: Disable risky DM channels
# Set dmPolicy: "disabled" for affected channels

# Step 4: Rotate ALL credentials
# - Gateway auth token
# - API keys (Anthropic/OpenAI)
# - Remote client secrets

# Step 5: Review what happened
# Check logs:
cat /tmp/clawdbot/clawdbot-$(date +%Y-%m-%d).log
# Review session transcripts:
ls ~/.clawdbot/agents/*/sessions/*.jsonl

# Step 6: Run a fresh security audit
clawdbot security audit --deep

9 Cost & API Economics

The Cost Model: Pay for Tokens, Not Software

Unlike subscription-based AI assistants that charge $20/month for a chat window, ClawdBot flips the model. The software is free. You pay only for the LLM tokens you actually consume through your chosen provider's API. This means you have full control over spending — from $0 with local models to whatever your usage demands with cloud APIs.

According to the official ClawdBot token use documentation, consumption is measured in tokens (approximately 4 characters per token for English). Everything the model receives counts: conversation history, tool calls, attachments, summaries, and system prompts.

Real-World Cost Reports from the Community

Community feedback on costs varies widely depending on usage patterns. Here is what users have reported on Hacker News and in GitHub Discussions:

The core issue, as user Jimmc414 identified, is that ClawdBot uses ~14,000 tokens just to initialize a session, with an additional ~1,000 tokens per interaction round even for short questions. User storystarling explained why: "The real cost driver with agents seems to be the repetitive context transmission since you re-send the history every step."

LLM API Pricing Comparison (January 2026)

Since ClawdBot passes costs through to your LLM provider, here is what the major providers charge per million tokens:

Run ClawdBot for $0: Local LLMs with Ollama

The most powerful cost optimization is eliminating API costs entirely by running open-source models locally. According to the official Ollama provider documentation, ClawdBot integrates natively with Ollama's OpenAI-compatible API and can auto-discover tool-capable models running on your machine.

Step 1: Install Ollama & Pull a Model

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Pull a capable model (choose based on your hardware)
ollama pull llama3.3          # 8B params — runs on 8GB RAM
ollama pull qwen2.5-coder:32b # 32B params — needs 32GB+ RAM
ollama pull deepseek-r1:32b   # 32B reasoning model

Step 2: Configure ClawdBot for Ollama

# Set the API key (any value works — Ollama doesn't require real auth)
export OLLAMA_API_KEY="ollama-local"

# Or set it permanently in ClawdBot config
clawdbot config set models.providers.ollama.apiKey "ollama-local"

Step 3: Set Your Primary Model

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "ollama/llama3.3"
      }
    }
  }
}

ClawdBot auto-discovers models at http://127.0.0.1:11434, keeping only models that report tool capability. All Ollama costs are set to $0 across the board — input, output, cache reads, and cache writes.

Explicit Ollama Configuration (Advanced)

If Ollama runs on a different host or you need non-auto-discovered models, define the provider explicitly:

{
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://ollama-host:11434/v1",
        "apiKey": "ollama-local",
        "api": "openai-completions",
        "models": [
          {
            "id": "llama3.3",
            "name": "Llama 3.3",
            "reasoning": false,
            "input": ["text"],
            "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 },
            "contextWindow": 8192,
            "maxTokens": 81920
          }
        ]
      }
    }
  }
}

8 Best Practices to Reduce Token Costs

Whether you use cloud APIs or want to minimize resource consumption with local models, these strategies make a significant difference:

1. Enable Prompt Caching with Heartbeat

Prompt caching is the single most powerful cost reduction technique, capable of cutting expenses by 60–95%. Anthropic charges 1.25x the base rate for cache writes but only 0.1x for cache reads. Configure your heartbeat interval just below the cache TTL to keep cached content warm:

agents:
  defaults:
    model:
      primary: "anthropic/claude-sonnet-4"
    models:
      "anthropic/claude-sonnet-4":
        params:
          cacheControlTtl: "1h"
    heartbeat:
      every: "55m"   # Just under 1h TTL to keep cache warm

2. Use Cache-TTL Pruning

Enable cache-TTL pruning in your gateway configuration. When a session goes idle past the TTL, ClawdBot automatically prunes and resets the cache window so subsequent requests re-use fresh cache rather than paying full input prices.

3. Use /compact for Long Sessions

The /compact command summarizes your conversation history, dramatically reducing the context window size. Use it proactively when sessions grow long — this prevents the compounding cost of re-sending ever-growing history with every message.

4. Model Cascading: Right Model for the Job

Not every task needs the most expensive model. Use a tiered approach:

• Claude Opus / GPT-4o: Complex reasoning, multi-step research, creative writing
• Claude Sonnet / GPT-4o: Everyday tasks, email drafting, code review
• Claude Haiku / GPT-4o Mini: Quick lookups, simple formatting, reminders
• Ollama (Local): Exploratory tasks, testing, privacy-sensitive conversations

5. Trim Large Tool Outputs

When ClawdBot uses tools (web browsing, file reading, terminal commands), the output feeds back into the context. Keep skill descriptions concise and minimize tool output verbosity to reduce unnecessary token consumption.

6. Monitor Spending with Built-in Commands

ClawdBot provides real-time cost visibility:

# See current session model, context usage, and estimated cost
/status

# Enable cost footer on every response
/usage cost

# View detailed per-file and per-tool token breakdown
/context detail

7. Set API Spending Limits

Most LLM providers let you set hard spending caps. Always configure these before heavy usage:

• Anthropic: Set monthly spending limits in the Anthropic Console under Billing
• OpenAI: Set hard and soft budget limits in the OpenAI Dashboard under Usage

8. Self-Host on Affordable Hardware

If running ClawdBot on a VPS instead of your local machine, community members on DEV Community recommend:

• Hetzner: From €3.49/month (4 GB RAM, 2 vCPUs)
• DigitalOcean: From $6/month (1 GB RAM) — $12/month with 2 GB recommended
• Linode: From $5/month (1 GB RAM)

Cost Estimate: What to Expect Monthly

10 Lobster Workflow Engine

Lobster is ClawdBot's native workflow shell — and one of its most powerful differentiators. According to the Lobster GitHub repository, it is a "typed, local-first macro engine that turns skills/tools into composable pipelines and safe automations — and lets Clawdbot call those workflows in one step."

Why Lobster Exists

Without Lobster, complex workflows require many back-and-forth tool calls between ClawdBot and the LLM. Each call costs tokens and introduces latency as the AI decides the next step. Lobster moves that orchestration into a deterministic runtime:

• One call instead of many: ClawdBot runs a single Lobster tool call and gets a structured result, saving tokens and reducing errors
• Typed pipelines: Data flows as objects and arrays, not raw text, preventing parsing failures
• Approval gates: Side effects (sending email, posting comments, making purchases) halt the workflow until explicitly approved by you
• Resume tokens: If a pipeline pauses for approval, it returns a token so you can continue later
• Local-first: No cloud dependency; everything runs on your machine

How It Works

Lobster workflows can be defined as YAML or JSON files with structured fields:

# weekly-review.yaml
name: weekly-review
args:
  vault_path: ~/Documents/brain

steps:
  - name: scan-inbox
    tool: brain-cli
    args: ["inbox", "list", "--json"]

  - name: categorize
    tool: ai
    prompt: "Categorize these inbox items: {{scan-inbox.output}}"

  - name: move-items
    tool: brain-cli
    args: ["inbox", "move", "{{categorize.output}}"]
    approval: required

  - name: generate-summary
    tool: ai
    prompt: "Create weekly summary from {{scan-inbox.output}}"

Real-World Lobster Use Case

The Lobster documentation showcases a "second brain" system that manages three Markdown vaults (personal, partner, shared). The CLI emits JSON for stats, inbox listings, and stale scans. Lobster chains those commands into workflows like weekly-review, inbox-triage, memory-consolidation, and shared-task-sync — each with approval gates where needed.

Lobster vs. Direct LLM Tool Calls

11 Common Problems & Fixes

Like any powerful system, ClawdBot has common gotchas that new users encounter. Based on the official documentation and community reports, here are the most frequently reported issues and their solutions.

Debugging Commands

# Best pasteable debug report
clawdbot status --all

# Surface risky/misconfigured DM policies
clawdbot doctor

# Quick diagnostics
clawdbot status
clawdbot health
clawdbot gateway status
clawdbot gateway probe

12 Success Stories

ClawdBot's real impact is best understood through the stories of people who use it daily. Here are some of the most notable use cases that have emerged from the growing community.

13 Community & Impact

ClawdBot has captured developer imagination in a way few open-source projects achieve so quickly. Its growth trajectory and community engagement paint a picture of a project that tapped into a deep, unfulfilled demand for truly capable personal AI.

By the Numbers

Why It Matters

ClawdBot represents a philosophical shift in personal AI. While tech giants build walled-garden assistants that monetize user data, ClawdBot demonstrates that a fully capable AI assistant can be:

• Self-hosted: No vendor lock-in, no data leaving your hardware
• Open source: Transparent code that anyone can audit, modify, and improve
• Model-agnostic: Works with Claude, GPT, or locally-hosted open-source models
• Community-driven: Skills and integrations built by users who need them

The project has been covered by international media, featured on tech forums, and praised across developer communities as "the AI assistant Siri should have been." Steinberger brings decades of experience building developer tools and enterprise software to the project, and it shows in the architectural decisions and code quality.

Getting Involved

The ClawdBot community welcomes contributions at every level:

• Build Skills: Create new integrations through the skills framework and publish to ClawdHub
• Report Issues: File bugs and feature requests on the GitHub Issues page
• Join Discord: Connect with other users, share workflows, and get help from the community
• Contribute Code: Submit pull requests — the project follows standard open-source contribution guidelines
• Share Workflows: Document and share your Lobster pipelines so others can benefit

? Frequently Asked Questions

15 Abbreviations & Glossary

Related Reading

Continue your AI and developer tools journey with these related guides from JZ Blog:

• Claude Code Complete Guide 2026: From Basics to Advanced MCP, Agents & Git Workflows — Master Claude Code CLI with MCP servers, agent workflows, and Git automation. Ideal companion to ClawdBot for developers using Anthropic’s AI ecosystem.
• Tableau AI Complete Guide: Features, Pricing & Power BI/Looker Comparison — Explore enterprise AI in business intelligence. Compare how AI assistants like ClawdBot and Tableau AI are transforming different workflows.
• Salesforce Spring ’26 Release: Complete Guide 2026 — Features Claude integration and Lightning Types MCP Tool. See how Salesforce is embedding the same AI models that power ClawdBot.
• GA4 & Tealium Implementation for Salesforce B2C Commerce — Analytics and AI-powered commerce integration. Covers Einstein AI features alongside traditional analytics for Salesforce B2C.