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?

What's New

Latest release v0.29.0 — workspace file tree + code canvas · declarative progress panel · multi-endpoint provider presets.

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

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
• 28 Built-in Skills — PDF/PPTX/DOCX/Excel generation, frontend design, canvas design, algorithmic art, Mermaid/SVG/infographics, Web Artifacts, Chrome automation (Abu-Browser), 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 — Built-in Browser Bridge + Chrome extension for web element interaction, form filling, screenshots, and JS execution
• 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:

macOS Users: If you see a "damaged" warning on first launch, run xattr -cr /Applications/Abu.app. See the Installation Guide for details.

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 (28 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 >= 18
• Rust >= 1.75 (Install Rust)
• Tauri 2.0 system dependencies (See docs)

Development

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

# Install dependencies
npm install

# Launch desktop app (uses dev-isolated config, fully separate from your installed Abu)
npm run tauri:dev

# Frontend only (no Rust required)
npm run dev

Build

npm run tauri build

Build artifacts are located in src-tauri/target/release/bundle/.

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/       # 28 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-Browser skill)
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!

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.