Abu-Cowork

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

Why Abu?

Feature · Abu · Regular AI Chat · Traditional Automation Autonomous planning & task execution · :white_check_mark: · :x: · :x: Read/write local files, run commands · :white_check_mark: · :x: · :white_check_mark: Natural language interaction · :white_check_mark: · :white_check_mark: · :x: 29 built-in skills + self-evolving (Abu grows its own) · :white_check_mark: · :x: · :x: Multi-conversation Project aggregation · :white_check_mark: · :x: · :x: Scheduled tasks & event triggers · :white_check_mark: · :x: · :white_check_mark: IM bot (Lark/DingTalk/WeCom/Slack) · :white_check_mark: · :x: · Partial Multi-agent parallel execution · :white_check_mark: · :x: · :x: Browser & computer control · :white_check_mark: · :x: · Partial 100% local data, privacy-safe · :white_check_mark: · :x: · :white_check_mark:

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

WelcomeNatural language input — conversation is the command Task ExecutionAutonomous planning & tool invocation for complex tasks Web Pages · Live PreviewGenerate a site and preview it live, side by side Content Creation · Live PreviewDraft documents with a real-time Markdown preview Plan ModeHigh-risk tasks show a plan first — runs only after you confirm Interactive QuestionsAbu pops an option card when it needs you to decide (single / multi-select) Multi-Agent ParallelUp to 5 background agents working at once, progress in real time Desktop Pet · Activity TrayA floating pet on your desktop, its tray showing Abu's live status Theme · DarkA polished, low-glare dark theme Theme · LightSwitch between light / dark / follow-system LabsIn-progress features, off by default, opt-in (currently hosting: Desktop Pet) Permission ControlFile access requires user authorization IM Channel Chat@Abu in Lark/DingTalk to interact Skills29 built-in skills + self-evolving + custom MCP ConnectorsOne-click integration with Playwright, GitHub & more Scheduled TasksCron-based scheduling for automated workflows Triggers / WatchHTTP, file changes, IM messages auto-trigger tasks AI Service ManagementMulti-provider management with health checks IM Channel ConfigConnect Lark, DingTalk, WeCom & more Personal MemoryRemembers your preferences and work habits Security SandboxSeatbelt sandbox + network isolation for privacy Soul (Personality)3 proactivity presets + custom SOUL.md for tone & style Diagnostic PanelOne-click self-check across AI / MCP / skills / network + bundle export Expert AgentsA library of expert agents you can summon by @name Usage StatsRequests, tokens, cache hits, and per model / skill usage Projects & WorkspacesGroup work into projects, each with its own skills & MCP Content Safety ScanThree 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//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:

Platform · File macOS (Apple Silicon) · Abu-x.x.x-mac-arm64.dmg macOS (Intel) · Abu-x.x.x-mac-x64.dmg Windows x64 · Abu-x.x.x-windows-x64-setup.exe

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)

Category · Skills Document Generation · PDF, PPTX, DOCX, XLSX Design & Creative · Frontend Design, Canvas Design, Algorithmic Art, SVG Diagram, Mermaid Diagram, Infographic, Slack GIF Creator, HTML Widget Browser Automation · Abu-Browser (built-in, isolated session), Abu-Chrome-Bridge (optional Chrome extension for existing tabs and sign-in state) Developer Tools · Claude API, MCP Builder, Web Artifacts Builder, Webapp Testing (Playwright) Content Writing · Doc Co-authoring, Brand Guidelines, Internal Comms Automation · Schedule, Trigger, Alert SOP Project Management · Skill Creator, Project Init, Create Agent Agent Reflection · Reflect — lets the agent look back on a run and distill learnings Theming · Theme Factory (10+ preset themes applicable to any artifact)

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

Layer · Technology Desktop Framework · Electron (main + preload + isolated React renderer) Frontend · React 19 + TypeScript (strict) + TailwindCSS v4 + Vite LLM Adapter · Dual-protocol adapter (Anthropic / OpenAI-compatible) State Management · Zustand + Immer + Persist Tool Protocol · MCP (@modelcontextprotocol/sdk) Web Search · Bing / Brave / Tavily / SearXNG Sandbox · macOS Seatbelt + path/command dual validation UI Components · Radix UI + Lucide Icons + shadcn-style Testing · Vitest + happy-dom (covers core store / agent / skill / memdir modules) Evaluation · Built-in OpenAI-protocol tool-selection eval runner (npm run eval:tool-selection)

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 (deve