English | 中文

Abu

Your AI Desktop Office Assistant — Just Leave It to Abu

A locally-run AI desktop assistant inspired by Claude Code's Cowork mode. Tell Abu what you need — it reads files, runs commands, writes docs, and builds reports, all on your machine.

Download · Quick Start · Features · User Guide · Build from Source

🚧 Multi-Harness integration in progress: Abu is evolving toward pluggable agent runtimes, with DeepSeek Harness among the first integration targets. Stable releases currently use Abu's native harness.

Why Abu?

What's New

Download the latest stable release · Read the full changelog

Recent highlights: Workspace file tree + code canvas (browse / preview / edit files in the side panel, CodeMirror source editing with auto-save, preview auto-refresh, version snapshots with rollback), declarative progress panel (the model declares its own plan steps and status via report_plan), inline visualization widgets (charts / HTML / Mermaid rendered inline in chat), multi-endpoint provider presets (Volcengine / Bailian / Zhipu access plans as curated presets + a unified add/edit modal), per-model capabilities (vision / tools / reasoning / token limits declared per model), plus doc comment-to-chat, full internationalization, and signed + notarized macOS builds.

Full changelog per release: see Releases.

Preview

Clean interface, powerful capabilities

Welcome Natural language input — conversation is the command	Task Execution Autonomous planning & tool invocation for complex tasks
Web Pages · Live Preview Generate a site and preview it live, side by side	Content Creation · Live Preview Draft documents with a real-time Markdown preview
Plan Mode High-risk tasks show a plan first — runs only after you confirm	Interactive Questions Abu pops an option card when it needs you to decide (single / multi-select)
Multi-Agent Parallel Up to 5 background agents working at once, progress in real time	Desktop Pet · Activity Tray A floating pet on your desktop, its tray showing Abu's live status
Theme · Dark A polished, low-glare dark theme	Theme · Light Switch between light / dark / follow-system
Labs In-progress features, off by default, opt-in (currently hosting: Desktop Pet)
Permission Control File access requires user authorization	IM Channel Chat @Abu in Lark/DingTalk to interact
Skills 29 built-in skills + self-evolving + custom	MCP Connectors One-click integration with Playwright, GitHub & more
Scheduled Tasks Cron-based scheduling for automated workflows	Triggers / Watch HTTP, file changes, IM messages auto-trigger tasks
AI Service Management Multi-provider management with health checks	IM Channel Config Connect Lark, DingTalk, WeCom & more
Personal Memory Remembers your preferences and work habits	Security Sandbox Seatbelt sandbox + network isolation for privacy
Soul (Personality) 3 proactivity presets + custom SOUL.md for tone & style	Diagnostic Panel One-click self-check across AI / MCP / skills / network + bundle export
Expert Agents A library of expert agents you can summon by @name	Usage Stats Requests, tokens, cache hits, and per model / skill usage
Projects & Workspaces Group work into projects, each with its own skills & MCP
Content Safety Scan Three permission modes (Request Approval / Smart Review / Full Autonomy) + scan agents / skills / memory for prompt injection & dangerous instructions

Features

Core Capabilities

• Autonomous Agent — More than chat: plans, invokes tools, reads/writes files, executes commands, and completes complex tasks end-to-end
• Plan Mode — For high-risk steps (delete / overwrite / send / install), Abu first presents a step-by-step plan and waits for you to click "Confirm & run"; only read-only ops run while awaiting approval
• Interactive questions — When Abu needs you to decide (pick an approach, provide a parameter), it pops an option card above the composer; single or multi-select, with an "Other" free-text row
• Per-conversation settings — Permission mode (Request Approval / Smart Review / Full Autonomy) and model can be switched per conversation without bleeding across chats
• Soul Personality System — Three proactivity presets (Quiet / Buddy / Butler) decide when Abu speaks up; customize tone, address, reply style, and boundaries via SOUL.md
• Self-Evolving Skills — After you run a multi-step complex flow, Abu proactively offers "want to crystallize this into a skill?" — one click drafts it, you review, you accept. Next time, just name the skill; no need to re-explain
• Smart Notification System — Menubar unread count / sidebar badge / system notification auto-routed; notices queued to inbox while you're in fullscreen / DnD, surfaced via badges once you're back; audit trail kept for 180 days
• Projects — Promote a workspace into a Project: conversations in the same direction auto-aggregate; each project gets its own default model, skill set, and MCP connectors
• Multi-Agent Parallel Execution — Run up to 5 background agents simultaneously, each executing tasks independently with real-time progress tracking
• Desktop Pet (Labs) — Transparent floating window; left-click opens main window, right-click menu, drag-to-edge dock; activity tray shows Abu's live status (working / awaiting approval / done) and lets you reply inline while it waits
• Theme switching — Light / dark / system, via Settings → Appearance
• Labs — In-progress features, off by default, opt-in, may change or be removed (currently hosting: Desktop Pet)
• Conversation Sharing — Export any conversation to JSON in one click; API keys and local paths are auto-redacted before sharing
• 29 Built-in Skills — PDF/PPTX/DOCX/Excel generation, frontend design, canvas design, algorithmic art, Mermaid/SVG/infographics, Abu's built-in browser, optional Chrome bridge, deep research, Agent self-reflection (reflect), workflow automation, and more — one-click install, fully customizable
• MCP Protocol — Connect to databases, search engines, GitHub, and other external services via Model Context Protocol
• Browser Automation — Zero-setup built-in browser for ordinary web tasks, plus an optional Chrome extension bridge for existing tabs and signed-in sessions
• Computer Use — Screenshot + mouse/keyboard control for desktop-level tasks, with sensitive app blocking, dangerous key interception, and a 5-minute session timeout
• HTTP Fetch — Built-in safety gateway: URL length cap, embedded credential blocking, cloud metadata endpoint blocking, 10 MB download limit, 60-second timeout — no more raw curl blind spots

AI Services & Models

• 12+ Cloud Providers — Anthropic Claude, OpenAI, DeepSeek, Qwen (Bailian), Doubao (Volcengine), Moonshot, Zhipu GLM, MiniMax, SiliconFlow, Qiniu, OpenRouter, and more
• Local Models — Zero-config Ollama integration with automatic local model discovery
• Custom Endpoints — Connect any OpenAI-compatible or Anthropic-compatible API
• Provider Management — Add, edit, delete, reorder providers with connection health checks and latency detection
• Model Selector — Switch models on-the-fly during conversations with capability badges (vision, tool use, web search, thinking, image generation, long context)
• Favorites & History — Star frequently used models, quickly switch between recent ones
• Image Generation — Built-in DALL-E 2 / DALL-E 3 support, plus any custom image-generation endpoint

Web Search

• Multiple Search Engines — Bing, Brave, Tavily, SearXNG (self-hosted, no API key needed)
• Independent Configuration — Search engine settings decoupled from main AI service

Automation & Triggers

• Scheduled Tasks — Cron-based scheduling (e.g., daily AI news digest at 9 AM); runs missed while the app was closed are replayed in time order on next launch
• Trigger System — Multiple event sources to automatically invoke agents:
  • File Watcher — Monitor file create/modify/delete events with glob patterns
  • HTTP Webhook — Auto-generated POST endpoints for external callbacks
  • IM Messages — Trigger tasks on specific incoming messages
  • Cron Schedule — Periodic execution on a time-based plan
• Trigger Permission Model — Four capability levels (read-only → safe tools → full access → custom whitelist) for fine-grained control

IM Channel Integration

Turn Abu into your team bot — just @Abu in your chat:

• Supported Platforms — D-Chat, Feishu (Lark), DingTalk, WeCom, Slack
• Session Management — Auto-isolate conversations by user/group/thread, auto-archive on timeout, "continue last" recovery
• Security Controls — User allowlist, workspace path restrictions, capability level enforcement
• Response Modes — Mention-only or all-messages

Memory & Context

• Three-tier file-based memory (Memdir architecture):
  • Personal Memory — ~/.abu/memory/ multi-file directory, applies across all projects, auto-organized by topic with MEMORY.md index injected into the prompt
  • Project Memory — ~/.abu/projects/<workspace>/memory/ auto-isolated per workspace, each entry is a separate .md file for easy reading, search, and pruning
  • Auto-migration — Legacy ~/.abu/agents/abu/memory.md and {workspace}/.abu/MEMORY.md are migrated automatically on startup
• Project Rules (hand-written):
  • ~/.abu/ABU.md — User-level rules (cross-project)
  • {workspace}/.abu/ABU.md — Project-level rules
  • {workspace}/.abu/rules/*.md — Modular rules (loaded alphabetically, max 20 files)
• Project Aggregation — Promote a workspace into a Project to aggregate its conversations; older conversations auto-backfilled with projectId on startup. Each project can independently configure default model, skill set, and MCP connectors
• Session Memory — Large tool outputs automatically persisted to disk; compact summaries kept in-context to prevent context explosion
• Persistent Todos — Per-conversation todo_write plans persisted to disk and survive app restarts
• Auto-Compaction — Intelligently compresses long conversation history while preserving key context

Security & Privacy

• Three Permission Modes — Request Approval (free read/write inside workspace; out-of-bounds writes and dangerous commands need confirmation; default) / Smart Review (out-of-bounds ops go to an AI reviewer: allow low-risk, block high-risk, ask only when unsure) / Full Autonomy (everything runs automatically except hard system red-lines); global default in Settings → Sandbox, also switchable per conversation via the chip above the composer
• Content Safety Scan — Scans agent-authored skills / memory entries to catch dangerous instructions, prompt injection, hardware commands, and 120+ other risk patterns
• OS Sandbox — macOS Seatbelt (sandbox-exec) / Windows PowerShell ConstrainedLanguage isolates shell command file access
• Network Isolation — Local proxy + domain whitelist + private-network toggle to control every outbound request
• Path & Command Safety — Sensitive directories (system folders, SSH keys, etc.) blocked by default; dangerous commands (rm -rf /, etc.) caught statically
• Computer Use Safeguards — 15+ blocked sensitive apps (Keychain, System Settings, WeChat, Slack, etc.), dangerous key interception (Cmd+Q, Cmd+Tab, Force Quit), session-level window hiding, 5-minute timeout
• Encrypted API Key Storage — Windows DPAPI / macOS AES-256-GCM with a hardware-UUID-derived key; keys are no longer written to localStorage in plaintext
• Local-First — Your data stays local, your API keys stay local — nothing goes through third-party servers
• Cross-Platform — Supports macOS (Apple Silicon / Intel) and Windows

Diagnostics & Troubleshooting

• One-Click Self-Check — Settings → Diagnostic, runs through AI service connectivity, data & permissions, MCP, skills, network, app environment
• Diagnostic Bundle Export — When something breaks, package logs / config / version info in one click (API keys and paths auto-redacted) and send it to the maintainer

For detailed feature documentation, see the User Guide

Download

Head to GitHub Releases to download the latest version:

Official macOS packages are signed and notarized. The Windows installer is current-user only and does not need administrator rights, but remains Authenticode-unsigned; SmartScreen may require More info → Run anyway. See the Installation Guide.

Quick Start

1. Configure AI Service

Open Abu → Settings → AI Service Management:

• Quickest setup: Choose a provider (e.g., DeepSeek, Anthropic), enter your API Key, click verify
• Local models: Install Ollama — Abu auto-discovers local models, no API key needed
• Custom endpoint: Enter any OpenAI-compatible API's Base URL and Key

2. Start Chatting

Return to the main screen, use the model selector to pick your preferred model, and start chatting.

Try these prompts:

Organize the files on my desktop by type

Extract the tables from this PDF and generate an Excel file

Every morning at 9 AM, search for the latest AI news and generate a daily digest

Use the frontend design skill to create a product landing page

Create a weekly report PPT for this week

3. Level Up

• Install skills: Settings → Customize → Skill Store — install PDF, PPT, frontend design, and more
• Connect MCP: Settings → MCP Connectors — one-click integration with GitHub, Playwright, etc.
• Set up schedules: Have Abu automatically search news, run data, send reports daily
• Connect IM: Settings → IM Channels — let your team @Abu directly in Lark/DingTalk

For more use cases, see the User Guide

Built-in Skills (29 total)

Beyond built-ins, Abu also supports Self-Evolving Skills — after multi-step complex flows, Abu proactively suggests "crystallize this into a skill" and grows a library tailored to your workflow. See User Guide → Skill System.

Tech Stack

Build from Source

Prerequisites

• Node.js 24 and npm
• Rust stable (Install Rust) for the native helper and sandbox launcher
• Platform build tools: Xcode Command Line Tools on macOS, or Visual Studio Build Tools on Windows

Development

# Clone the repo
git clone https://github.com/PM-Shawn/Abu-Cowork.git
cd Abu-Cowork

# Prepare worktree-local dependencies, Electron/browser runtimes, sidecar,
# native helper, sandbox launcher, and the OSS renderer
npm run setup:electron-dev

# Launch the Electron desktop app. The OSS renderer is rebuilt before launch.
npm run electron:dev

# Enterprise worktree: prepare and launch the private Enterprise renderer
npm run setup:electron-dev:enterprise
npm run electron:dev:enterprise

# Frontend-only preview (not desktop acceptance)
npm run dev

Tauri is not a feature-development or acceptance target. Its source remains only for compatibility with already shipped versions, migration, and rollback.

Build

npm run dist:electron

Build artifacts are written to release-electron/. Build and validate distributable packages on the target operating system; a macOS cross-build is not Windows acceptance.

Source/fork packages do not use Abu's production updater or migrate installed Abu data. If you plan to distribute a modified build, read the Fork & Distribution Guide first.

Testing

npm test              # Run tests
npm run test:watch    # Watch mode
npm run test:coverage # Coverage report
npm run lint          # ESLint check

Project Structure

src/
├── components/       # React UI components
│   ├── chat/         # Chat interface, messages, model selector
│   ├── sidebar/      # Sidebar navigation (with collapsed Recents search)
│   ├── panel/        # Right-side detail panel (workspace, project memory/instructions)
│   ├── customize/    # Customization (skills, agents, models)
│   ├── schedule/     # Scheduled task views
│   ├── trigger/      # Trigger ("on-call") management views
│   ├── settings/     # System settings (16 panels, see settings/sections/)
│   ├── preview/      # File preview (PDF/Office/image/Markdown)
│   └── ui/           # Base UI components (shadcn/Radix)
├── core/             # Core engine (non-UI)
│   ├── agent/        # Agent loop, background agents, project rules
│   ├── llm/          # LLM adapter layer (Claude / OpenAI-compatible / Ollama)
│   ├── tools/        # Tool registry, built-in tools, safety checks
│   ├── mcp/          # MCP client
│   ├── skill/        # Skill loading & preprocessing
│   ├── search/       # Web search (Bing/Brave/Tavily/SearXNG)
│   ├── memdir/       # File-based memory system (personal/project, multi-file + index)
│   ├── scheduler/    # Scheduling engine
│   ├── trigger/      # Trigger engine (HTTP/file/cron/IM)
│   ├── im/           # IM channel adapters (D-Chat/Lark/DingTalk/WeCom/Slack)
│   ├── permissions/  # Permission model & capability levels
│   ├── context/      # Context management & auto-compaction
│   ├── session/      # Session management & disk persistence
│   ├── sandbox/      # Sandbox configuration
│   ├── logging/      # Structured logging
│   └── updates/      # Auto-update channel
├── eval/             # Tool-call / model capability eval scaffold (developer use)
├── stores/           # Zustand state management
├── hooks/            # React Hooks
├── i18n/             # Internationalization (Chinese / English)
├── types/            # TypeScript type definitions
└── utils/            # Utility functions

builtin-skills/       # 29 built-in skills (one directory each)
builtin-agents/       # Built-in agent definitions (placeholder)
abu-browser-bridge/   # Browser bridge MCP Server
abu-chrome-extension/ # Chrome extension (used by the Abu-Chrome-Bridge skill)
electron/             # Electron main process, preload bridge, native hosts
sidecar/              # Agent/runtime sidecar process
src-tauri/
├── src/
│   ├── computer_use.rs    # Screenshot + mouse/keyboard + sensitive app blocking
│   ├── feishu_ws.rs       # Lark/Feishu WebSocket long connection
│   ├── overlay.rs         # Computer-use status overlay
│   ├── proxy.rs           # Network isolation proxy
│   ├── sandbox.rs         # macOS Seatbelt / Win ConstrainedLanguage
│   ├── trigger_server.rs  # HTTP trigger server
│   └── window_info.rs     # Behavior awareness (active app sampling)
└── tauri.conf.json

Documentation

Contributing

Issues and Pull Requests are welcome. Read the Fork & Distribution Guide before shipping a modified desktop package.

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

License

Apache License 2.0 — Free to use, modify, and distribute, including commercial use. Copyright notices must be retained. Enterprise edition requires a license, offering team collaboration, SSO, audit logs, and private deployment support. Contact us.