LobsterAI — All-in-One Personal Assistant Agent

LobsterAI is an all-in-one personal assistant Agent developed by NetEase Youdao. It works around the clock to handle your everyday tasks — data analysis, making presentations, generating videos, writing documents, searching the web, sending emails, scheduling tasks, and more.

At its core is Cowork mode — it executes tools, manipulates files, and runs commands in a local or sandboxed environment, all under your supervision. You can also reach the Agent via WeChat, WeCom, DingTalk, Feishu, QQ, Telegram, Discord, and more — getting work done from your phone anytime, anywhere.

Key Features

• All-in-One Productivity Assistant — Data analysis, PPT creation, video generation, document writing, web search, email — covers the full range of daily work
• Local + Sandbox Execution — Run tasks directly on your machine or in an OpenClaw sandbox environment
• Built-in Skills — Office document generation, web search, Playwright automation, Remotion video generation, and more
• Windows Built-in Python Runtime — Windows packages bundle a ready-to-use Python interpreter runtime; Python skill dependencies can be installed on demand
• Scheduled Tasks — Create recurring tasks via conversation or the GUI — daily news digests, inbox cleanup, periodic report generation, and more
• Persistent Memory — Automatically extracts user preferences and personal facts from conversations, remembers your habits across sessions, and gets smarter the more you use it
• Mobile via IM — Control your Agent remotely from your phone through WeChat, WeCom, DingTalk, Feishu, QQ, Telegram, Discord, and more
• Permission Gating — All tool invocations require explicit user approval before execution
• Cross-Platform — macOS (Intel + Apple Silicon), Windows, Linux desktop, plus mobile coverage via IM
• Local Data — SQLite storage keeps your chat history and configuration on your device

How It Works

Quick Start

Prerequisites

• Node.js >= 24 < 25
• npm

Install & Develop

# Clone the repository
git clone https://github.com/netease-youdao/LobsterAI.git
cd LobsterAI

# Install dependencies
npm install

# Start development (Vite dev server + Electron with hot reload)
npm run electron:dev

The dev server runs at http://localhost:5175 by default.

Develop with OpenClaw Agent Engine

LobsterAI can use OpenClaw as its agent engine. The required OpenClaw version is pinned in package.json under openclaw.version.

# First run: automatically clones and builds OpenClaw (may take several minutes)
npm run electron:dev:openclaw

# Subsequent runs: skips build if the pinned version hasn't changed
npm run electron:dev:openclaw

By default, OpenClaw source is cloned/managed at ../openclaw (relative to this repo). Override with:

OPENCLAW_SRC=/path/to/openclaw npm run electron:dev:openclaw

To force a rebuild even when the version hasn't changed:

OPENCLAW_FORCE_BUILD=1 npm run electron:dev:openclaw

To skip the automatic version checkout (e.g., when developing OpenClaw locally):

OPENCLAW_SKIP_ENSURE=1 npm run electron:dev:openclaw

Production Build

# TypeScript compilation + Vite bundle
npm run build

# ESLint check
npm run lint

Packaging & Distribution

Uses electron-builder to produce platform-specific installers. Output goes to release/.

# macOS (.dmg)
npm run dist:mac

# macOS - Intel only
npm run dist:mac:x64

# macOS - Apple Silicon only
npm run dist:mac:arm64

# macOS - Universal (both architectures)
npm run dist:mac:universal

# Windows (.exe NSIS installer)
npm run dist:win

# Linux (.AppImage & .deb)
npm run dist:linux

Desktop packaging (macOS / Windows / Linux) bundles a prebuilt OpenClaw runtime under Resources/cfmind. The pinned OpenClaw version (package.json → openclaw.version) is automatically fetched and built during packaging — no manual setup needed. The build is cached: if the runtime for the pinned version already exists locally, the build step is skipped automatically.

You can also build OpenClaw runtime manually:

# Build runtime for current host platform (auto-detect mac/win/linux + arch)
npm run openclaw:runtime:host

# Build explicit targets
npm run openclaw:runtime:mac-arm64
npm run openclaw:runtime:win-x64
npm run openclaw:runtime:linux-x64

Override OpenClaw source path with an environment variable when needed:

OPENCLAW_SRC=/path/to/openclaw npm run dist:win

Windows builds bundle a portable Python runtime under resources/python-win (included as installer resource python-win), so end users do not need to install Python manually. The bundled runtime is interpreter-focused and does not preinstall LobsterAI skill Python packages; those can be installed at runtime on demand. By default, packaging downloads the official Python embeddable runtime from python.org if no prebuilt archive is provided. For offline/non-network builds, provide a prebuilt runtime archive explicitly.

Offline/runtime source options for packaging:

• LOBSTERAI_PORTABLE_PYTHON_ARCHIVE: Local prebuilt runtime archive path (recommended for offline CI/CD)
• LOBSTERAI_PORTABLE_PYTHON_URL: Download URL for the prebuilt runtime archive
• LOBSTERAI_WINDOWS_EMBED_PYTHON_VERSION / LOBSTERAI_WINDOWS_EMBED_PYTHON_URL / LOBSTERAI_WINDOWS_GET_PIP_URL: Optional overrides for Windows-host bootstrap sources

Architecture

LobsterAI uses Electron's strict process isolation. All cross-process communication goes through IPC.

Process Model

Main Process (src/main/main.ts):

• Window lifecycle management
• SQLite persistence
• OpenClaw agent engine (primary) + CoworkEngineRouter dispatch layer
• IM Gateways — WeChat, WeCom, DingTalk, Feishu, QQ, Telegram, Discord, POPO remote access
• 40+ IPC channel handlers
• Security: context isolation enabled, node integration disabled, sandbox enabled

Preload Script (src/main/preload.ts):

• Exposes window.electron API via contextBridge
• Includes cowork namespace for session management and stream events

Renderer Process (src/renderer/):

• React 18 + Redux Toolkit + Tailwind CSS
• All UI and business logic
• Communicates with main process exclusively through IPC

Directory Structure

src/
├── main/                           # Electron main process
│   ├── main.ts                     # Entry point, IPC handlers
│   ├── preload.ts                  # Security bridge
│   ├── sqliteStore.ts              # SQLite storage
│   ├── coworkStore.ts              # Session/message CRUD
│   ├── skillManager.ts             # Skill management
│   ├── im/                         # IM gateways (WeChat/WeCom/DingTalk/Feishu/QQ/Telegram/Discord/POPO)
│   └── libs/
│       ├── agentEngine/
│       │   ├── coworkEngineRouter.ts    # Dispatch layer (routes sessions to the active engine)
│       │   ├── openclawRuntimeAdapter.ts # Primary OpenClaw gateway adapter
│       │   └── claudeRuntimeAdapter.ts  # Legacy built-in adapter (deprecated)
│       ├── coworkRunner.ts          # Legacy built-in executor (deprecated)
│       ├── openclawEngineManager.ts # OpenClaw runtime lifecycle (install/start/status)
│       ├── openclawConfigSync.ts    # Syncs cowork config → OpenClaw config files
│       └── coworkMemoryExtractor.ts # Memory extraction
│
├── renderer/                        # React frontend
│   ├── App.tsx                     # Root component
│   ├── types/                      # TypeScript definitions
│   ├── store/slices/               # Redux state slices
│   ├── services/                   # Business logic (API/IPC/i18n)
│   └── components/
│       ├── cowork/                 # Cowork UI components
│       ├── artifacts/              # Artifact renderers
│       ├── skills/                 # Skill management UI
│       ├── im/                     # IM integration UI
│       └── Settings.tsx            # Settings panel
│
SKILLs/                              # Skill definitions
├── skills.config.json              # Skill enable/disable and ordering
├── web-search/                     # Web search
├── docx/                           # Word document generation
├── xlsx/                           # Excel spreadsheets
├── pptx/                           # PowerPoint presentations
├── pdf/                            # PDF processing
├── remotion/                       # Video generation
├── playwright/                     # Web automation
└── ...                             # More skills

Cowork System

Cowork is the core feature of LobsterAI — an AI working session system powered by OpenClaw as the primary agent engine. Designed for productivity scenarios, it can autonomously complete complex tasks like data analysis, document generation, and information retrieval.

Execution Modes