Comprehensive Overview of LobsterAI: A 24/7 All-in-One Personal Assistant Agent

Introduction to LobsterAI

LobsterAI is a cutting-edge, all-in-one personal assistant agent developed by NetEase Youdao, designed to streamline productivity through intelligent automation. Unlike traditional assistants that rely on simple voice commands or predefined tasks, LobsterAI operates as an autonomous AI agent capable of executing complex workflows—from data analysis and document generation to video creation and web searches—while maintaining strict security and privacy controls.

Built using modern web technologies, including Electron, React, TypeScript, and the Claude Agent SDK, LobsterAI integrates seamlessly across multiple platforms: macOS (Intel & Apple Silicon), Windows, Linux, and mobile devices via instant messaging (IM) platforms. Its architecture ensures high performance while balancing security with user autonomy.

Core Features of LobsterAI

1. All-in-One Productivity Assistant

LobsterAI consolidates multiple productivity tools into a single interface, allowing users to perform tasks such as:

Data Analysis & Reporting – Process datasets and generate insights.
Presentation Creation (PPT/PDF) – Automatically draft slides or reports in Word/Excel formats.
Video Generation (Remotion) – Create promotional videos, animations, or data visualizations.
Web Search & Automation (Playwright) – Execute browser tasks, scrape websites, and automate workflows.
Email Management (IMAP-SMTP) – Send/receive emails via scheduled tasks.

This modular approach ensures versatility for professionals, students, and creatives alike.

2. Local + Sandbox Execution

LobsterAI supports two execution modes:

Local Mode – Runs tasks directly on the user’s machine for maximum speed.
Sandbox Mode (Alpine Linux VM) – Executes tasks in an isolated virtual environment to prevent system interference or security risks.

This dual approach ensures efficiency while maintaining safety, especially when handling sensitive data.

3. Built-in Skills & Customization

LobsterAI comes pre-loaded with 16+ built-in skills, including:

Document Generation (docx/xlsx/pptx/pdf) – Automatically create professional reports.
Video Production (Remotion) – Generate animated content from text prompts.
Web Automation (Playwright) – Simulate browser interactions for testing or data extraction.
Design Tools (Canvas/Frontend Design) – Create visual assets like posters and UI prototypes.
Scheduled Tasks – Set up recurring workflows (e.g., daily news summaries, inbox cleanup).
Email & IM Integration – Send/receive messages via IM platforms like Telegram, Discord, or Feishu.

Users can also extend functionality by creating custom skills using the skill-creator module.

4. Windows-Specific Python Runtime

Unlike many AI assistants that require users to install Python separately, LobsterAI bundles a portable Python interpreter for Windows. This ensures compatibility without manual setup:

The bundled runtime includes a minimal Python environment.
Additional dependencies are installed dynamically when needed.
Users can download the latest Python embeddable runtime from Microsoft’s official site if required.

5. Scheduled Tasks & Automation

LobsterAI excels in automation through scheduled tasks, allowing users to:

Set recurring workflows (e.g., "Generate a weekly business report at 9 AM").
Use Cron expressions for precise timing (minute, hourly, daily, weekly, monthly).
Trigger tasks via natural language or the GUI.

Example use cases include:

News Aggregation – Collect industry updates and summarize them daily.
Inbox Management – Categorize emails automatically.
Data Reporting – Generate periodic analytics dashboards.

6. Persistent Memory & Personalization

LobsterAI maintains a local SQLite database to store conversation history, preferences, and personal details. This enables:

Memory Extraction – Automatically captures user habits (e.g., "I prefer Markdown format").
Explicit Requests – Users can manually input preferences (e.g., "Remember my project name: LobsterAI").
Personalized Responses – The AI adapts to user style, reducing redundancy in future interactions.

Memory settings allow fine-tuning: | Setting | Description | |---------|------------| | Memory Toggle | Enable/disable memory extraction. | | Auto Capture | Automatically extract memories from conversations. | | Capture Strictness | Adjust sensitivity (Strict/Standard/Relaxed). | | Max Injected Items | Limit the number of stored memories per session (default: 12). |

7. IM Integration for Mobile Control

LobsterAI extends its functionality to mobile devices via instant messaging platforms, allowing remote command execution:

Supported Platforms:
DingTalk (Enterprise robot)
Feishu (Lark) – Chinese enterprise messaging.
Telegram & Discord – Open-source IM bots.
NetEase IM & Bee – Personal digital assistants.

Users can send commands from their phone (e.g., "Analyze this dataset") and receive results on desktop or mobile.

Technical Architecture of LobsterAI

1. Process Model

LobsterAI follows an Electron-based architecture, ensuring security and performance:

Main Process (src/main/main.ts)
Manages window lifecycle, SQLite persistence, and CoworkRunner (the AI execution engine).
Handles IM gateways (Telegram, Discord, etc.) via contextBridge.
Enforces strict process isolation with sandboxing.
Preload Script (src/main/preload.ts)
Exposes the Electron API securely using contextBridge.
Provides a cowork namespace for session management and real-time events.
Renderer Process (src/renderer/)
Built with React 18 + Redux Toolkit + Tailwind CSS.
Handles UI rendering, business logic, and IPC communication.
Uses TypeScript for type safety.

2. Directory Structure

src/
├── main/
│   ├── main.ts (Electron entry point)
│   ├── preload.ts (Security bridge)
│   ├── sqliteStore.ts (SQLite database)
│   ├── coworkStore.ts (Session management)
│   └── libs/ (Core modules: CoworkRunner, Sandbox VM, Memory Extraction)
├── renderer/
│   ├── App.tsx (Root React component)
│   ├── types/ (TypeScript definitions)
│   ├── store/slices/ (Redux state slices)
│   ├── services/ (Business logic & API calls)
│   └── components/ (UI elements: Cowork UI, Skill Management, IM Integration)
└── SKILLs/
    ├── skills.config.json (Skill enable/disable settings)
    ├── web-search/ (Web search module)
    ├── docx/ (Word document generator)
    ├── xlsx/ (Excel spreadsheet creator)
    └── ... (Additional skills like pptx, pdf, remotion, etc.)

3. Cowork System (AI Execution Engine)

The Cowork system is the heart of LobsterAI’s AI capabilities:

Execution Modes:
auto – Automatically selects execution mode based on context.
local – Runs tasks directly on the user’s machine (fastest).
sandbox – Executes in an isolated Alpine Linux VM for security.
Stream Events – Real-time bidirectional communication via IPC:
message – New session message added.
permissionRequest – User approval needed before executing a tool.
complete – Task execution finished successfully.
error – Execution failure (e.g., file access denied).
Permission Control – All file/network operations require explicit user approval via the CoworkPermissionModal.

How to Install and Run LobsterAI

Prerequisites

Node.js v24–v24.99 (must be ≥ 24, < 25).
npm (Node Package Manager).

Development Setup

Clone the repository:

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

Install dependencies:

   npm install

Start the development server (Vite + Electron with hot reload):

   npm run electron:dev

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

Production Build

For distribution, LobsterAI uses electron-builder to generate platform-specific installers:

# Compile TypeScript + Vite bundle
npm run build

# Check for linting errors
npm run lint

# Generate installers (choose one):
npm run dist:mac       # macOS (.dmg) – Intel only
npm run dist:mac:x64   # macOS – Apple Silicon only
npm run dist:mac:arm64 # macOS – Universal (both)
npm run dist:win        # Windows (.exe NSIS installer)
npm run dist:linux      # Linux (.AppImage & .deb)

Windows-Specific Python Handling

Bundles a portable Python runtime in resources/python-win.
Users do not need to install Python manually.
Additional Python packages are installed dynamically when required.

Security Model of LobsterAI

LobsterAI prioritizes security through multiple layers:

Process Isolation – Uses Electron’s strict sandboxing with context isolation enabled.
Permission Gating – All file/network operations require explicit user approval.
Sandbox Execution (Optional) – Runs tasks in an isolated Alpine Linux VM if enabled.
Content Security –

HTML sandboxing via DOMPurify.
Strict Mermaid diagram rendering.

Workspace Boundaries – Restricts file operations to the designated working directory.
IPC Validation – All cross-process calls are type-checked for security.

Tech Stack Overview

| Layer | Technology Used | |----------------|----------------| | Framework | Electron 40 | | Frontend | React 18 + TypeScript | | Build Tool | Vite 5 | | Styling | Tailwind CSS 3 | | State Mgmt | Redux Toolkit | | AI Engine | Claude Agent SDK (Anthropic) | | Storage | SQLite (via sql.js) | | Markdown | react-markdown + remark-gfm + rehype-katex | | Diagrams | Mermaid | | Security | DOMPurify | | IM Integration | dingtalk-stream, grammY, discord.js |

Internationalization & Customization

Languages Supported

English
Chinese (via README.zh.md)

Users can switch languages in the Settings panel.

App Configuration

Stored in SQLite’s kv table.
Editable via the Settings UI for:
Working directory settings.
Cowork execution mode (auto, local, or sandbox).
System prompt customization.

Development Guidelines

LobsterAI follows a structured development approach:

TypeScript Strict Mode – Ensures type safety.
Functional Components + Hooks – Clean React implementation.
2-Space Indentation, Single Quotes, Semicolons – Consistent coding style.
PascalCase for Components, camelCase for functions/variables.
Redux Slices – Follow the naming convention (*Slice.ts).

Contributing to LobsterAI

Fork the repository:

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

Create a new branch:

   git checkout -b feature/your-feature

Commit changes with descriptive messages (e.g., feat: add artifact toolbar).
Push and open a Pull Request with:

A summary of changes.
Screenshots for UI modifications.
Notes on Electron-specific behavior.

Security & Compliance

MIT License – Open-source, permissive license allowing modifications.
No Data Leakage – All data is stored locally in SQLite (lobsterai.sqlite).
Privacy-Focused – No third-party tracking; user control over memory extraction.

Conclusion: Why Choose LobsterAI?

LobsterAI stands out as a next-generation personal assistant due to its: ✅ All-in-one productivity suite (data, docs, videos, automation). ✅ Secure execution modes (local + sandboxed VMs). ✅ Customizable skills & scheduled tasks. ✅ Mobile IM integration for remote control. ✅ Persistent memory for personalized interactions.

Whether you’re a developer, marketer, student, or creative, LobsterAI adapts to your workflow—making complex tasks effortless. With its open-source nature and robust security model, it’s a powerful tool for anyone seeking smarter automation.

Visual References from the Input

Logo – The official LobsterAI branding.
Architecture Diagram – Shows the core Electron-based process flow (Main Process ↔ Renderer Process ↔ Cowork System).

This detailed description captures every aspect of LobsterAI’s functionality, architecture, and user experience while maintaining clarity and structure.

LobsterAI: Your 24/7 AI Personal Assistant