---

Why Abu?

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

---

What's New

Latest release v0.25.0 — Labs · desktop pet interaction upgrade · light / dark / system theme switching.

Recent highlights: Labs experiment framework (currently hosting: Desktop Pet), Desktop Pet interaction upgrade + activity tray, theme switching (light / dark / system), per-conversation settings (pinned model + permission mode per conversation), interactive question cards (when Abu needs you to decide, it pops an option card above the composer — single or multi-select), Plan Mode (high-risk tasks show a step-by-step plan and wait for your approval before proceeding), model capability badges + token usage stats (backed by models.dev-maintained capability tables).

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
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 Dark is the default design direction	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 28 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
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
• 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:

| Platform | File | |----------|------| | macOS (Apple Silicon) | Abux.x.xaarch64.dmg | | macOS (Intel) | Abux.x.xx64.dmg | | Windows | Abux.x.xx64-setup.exe |

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)

| 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 (Chrome bridge with auto extension setup, drives a real browser) | | 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 | Tauri 2.0 (Rust + Web) | | 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 >= 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

| Document | Description | |----------|-------------| | User Guide | Complete product features and usage instructions | | Installation Guide | Platform-specific installation and troubleshooting |

Contributing

Issues and Pull Requests are welcome!

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

Feedback & Community

Got questions or ideas? Scan the QR code to join the WeChat group:

Support

If Abu has been helpful to you, feel free to buy the author a coffee:

Star History

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.