LobsterAI

A 24/7 all-scenario office assistant Agent that gets real work done — built by NetEase Youdao

The first open-source, desktop-grade Agent from a major Chinese tech company — publicly praised by OpenClaw's founder.

⬇️ Download  ·  💬 Community  ·  ⭐ Star History  ·  English · 中文

LobsterAI is an all-scenario office assistant Agent built by NetEase Youdao — the first open-source, desktop-grade Agent from a major Chinese tech company. It works around the clock to get real work done: data analysis, slide decks, video generation, document writing, web research, email, scheduled jobs, and more.

Unlike chat-only assistants, LobsterAI is desktop-grade. Through its Cowork mode it connects to your files, terminal, browser, and local projects — executing tools and running commands directly in your real working environment, with every sensitive action gated behind your approval. Spin up purpose-built Agents (stock research, content writing, lesson planning…), extend it with Expert Kits, Skills, and MCP servers, and reach it from your phone via WeChat, WeCom, DingTalk, Feishu, QQ, Telegram, Discord, and more — command your computer to work anytime, anywhere.

Why LobsterAI

• 🔓 Open source, secure & trustworthy — 100% open-source code with transparent capabilities; permissions, data, and execution flows are all auditable
• 🖥️ Desktop-grade Agent — Connects to your files, terminal, browser, and local projects, working directly inside your real environment instead of a sandboxed chat box
• 🧩 OpenClaw ecosystem — Built on the open-source OpenClaw Agent framework, with continuous access to new Skills, tools, MCP servers, and models
• 📱 Command your computer from your phone — Drive LobsterAI 24/7 through WeChat, WeCom, DingTalk, Feishu, QQ, Telegram, Discord, and more
• 🔒 Local data, controlled actions — Sessions, configuration, and memory stay on your device; every tool call is gated and logged

Capabilities

• All-scenario productivity — Data analysis, PPT creation, video generation, document writing, web search, email — covering the full range of daily work
• Custom Agents — Create purpose-built Agents (e.g. Stock Expert, Content Writer, Lesson Planner) each with its own identity, skills, and IM channels
• Expert Kits & Skills — 28 built-in skills plus installable Expert Kits; build your own with skill-creator and hot-load at runtime
• MCP support — Connect external tools and data sources through Model Context Protocol servers
• Scheduled tasks — Create recurring jobs by conversation or GUI — daily news digests, inbox cleanup, periodic reports, and more
• Persistent memory — Remembers your preferences and context across sessions via file-based memory; gets smarter the more you use it
• Local-first — Run tasks directly on your machine
• Cross-platform — macOS (Intel + Apple Silicon) and Windows desktop, plus mobile reach via IM
• Windows built-in Python runtime — Windows packages bundle a ready-to-use Python interpreter; skill dependencies install on demand

Real-World Scenarios

How It Works

Quick Start

Prerequisites

• Node.js >= 24 < 25
• npm

1. Clone & install

git clone https://github.com/netease-youdao/LobsterAI.git
cd LobsterAI
npm install

2. Start the app

# First run: builds the OpenClaw runtime, then starts the app.
# Clones & builds OpenClaw on first run — this can take several minutes.
npm run electron:dev:openclaw

Once the runtime has been built, day-to-day development can use the faster command — it reuses the existing runtime and skips the OpenClaw build step:

npm run electron:dev

The Vite dev server runs at http://localhost:5175. By default the app connects to LobsterAI's production services, so no extra setup is needed to sign in and use it.

OpenClaw build options

The required OpenClaw version is pinned in package.json under openclaw.version, and its source is cloned/managed at ../openclaw (relative to this repo) by default.

# Use a custom OpenClaw source path
OPENCLAW_SRC=/path/to/openclaw npm run electron:dev:openclaw

# Force a rebuild even when the pinned version hasn't changed
OPENCLAW_FORCE_BUILD=1 npm run electron:dev:openclaw

# 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

# 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

# macOS - Intel only
KEYFROM=xxx npm run dist:mac:x64

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

# Windows (.exe NSIS installer)
npx cross-env KEYFROM=xxx npm run dist:win

# 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:mac-x64
npm run openclaw:runtime:win-x64
npm run openclaw:runtime:linux-x64

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

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.

Skills System

LobsterAI ships with a rich set of built-in skills covering productivity, creative, investment research, and automation scenarios, configured via SKILLs/skills.config.json. Below are some typical examples:

Custom skills can be created via skill-creator and hot-loaded at runtime.

Scheduled Tasks

LobsterAI supports scheduled tasks that let the Agent automatically execute recurring work on a set schedule.

How to Create

• Conversational — Tell the Agent in natural language (e.g., "collect tech news for me every morning at 9 AM"), and it will create the scheduled task automatically
• GUI — Add tasks manually in the Scheduled Tasks management panel with a visual interface for configuring timing and task content

Typical Scenarios

Scheduled tasks are powered by Cron expressions, supporting minute, hourly, daily, weekly, and monthly intervals. When a task fires, it automatically starts a Cowork session. Results can be viewed on the desktop or pushed to your phone via IM.

IM Integration — Mobile Remote Control

LobsterAI can bridge the Agent to multiple IM platforms. Send a message from your phone via IM to remotely trigger the desktop Agent — command your personal assistant anytime, anywhere.

Configure the corresponding platform Token/Secret in the Settings panel to enable. Once set up, you can send instructions directly to the Agent from your phone IM (e.g., "analyze this dataset", "make a weekly summary PPT"), and the Agent will execute on the desktop and return results.

Persistent Memory

LobsterAI's memory system is built on OpenClaw and persists information as files in the working directory, so the Agent remembers your preferences and context across sessions.

Memory File Structure

How Memories Are Written

• Explicit instructions — Say "remember that…" or "from now on reply in English," and the Agent calls the write tool to save to MEMORY.md before acknowledging — no silent "mental notes"
• Agent-initiated — The Agent can proactively write important findings, configurations, or environment notes to memory files during task execution, without explicit prompting
• GUI management — Add, edit, or delete entries in MEMORY.md directly from the Settings panel; keyword search is supported

How It Works

At the start of every session, OpenClaw reads SOUL.md, USER.md, today's and yesterday's memory/YYYY-MM-DD.md, and MEMORY.md in sequence, injecting them as context. This lets the Agent pick up where it left off without you needing to re-explain preferences.

Memory writes go through file tools — there is no background extraction or inference. Content is fully under user or Agent control.

Data Storage

All data is stored in a local SQLite database (lobsterai.sqlite in the user data directory).

Security Model

LobsterAI enforces security at multiple layers:

• Process Isolation — Context isolation enabled, node integration disabled
• Permission Gating — Tool invocations require explicit user approval
• Workspace Boundaries — File operations restricted to the designated working directory
• IPC Validation — All cross-process calls are type-checked

Tech Stack

Configuration

App Configuration

App-level config is stored in the SQLite kv table, editable through the Settings panel.

Cowork Configuration

Cowork session config includes:

• Working Directory — Root directory for Agent operations
• System Prompt — Customize Agent behavior

Internationalization

Currently English and Chinese are supported. Switch languages in the Settings panel.

OpenClaw Version Management

{
  "openclaw": {
    "version": "v2026.4.14",
    "repo": "https://github.com/openclaw/openclaw.git"
  }
}

Development Guidelines

• TypeScript strict mode, functional components + Hooks
• 2-space indentation, single quotes, semicolons
• Components: PascalCase; functions/variables: camelCase; Redux slices: *Slice.ts
• Tailwind CSS preferred; avoid custom CSS
• Commit messages follow type: short imperative summary (e.g., feat: add artifact toolbar)

Testing

# run all tests
npm test

# run tests for a specific module (Vitest filename filter)
npm test -- logger
npm test -- cowork

src/main/
├── foo.ts
└── foo.test.ts

import { test, expect } from 'vitest';

test('log file pattern matches daily name', () => {
  expect(/^main-\d{4}-\d{2}-\d{2}\.log$/.test('main-2026-03-20.log')).toBe(true);
});

Community

Join our WeChat group to get help, share feedback, and stay up to date:

Contributing

1. Fork this repository
2. Create your feature branch (git checkout -b feature/your-feature)
3. Commit your changes (git commit -m 'feat: add something')
4. Push to the branch (git push origin feature/your-feature)
5. Open a Pull Request

Please include in your PR description: a summary of changes, linked issue (if any), screenshots for UI changes, and notes on any Electron-specific behavior changes.

License

MIT License

Star History

Built and maintained by NetEase Youdao.