OpenAkita

Open-Source Multi-Agent AI Assistant — Not Just Chat, an AI Team That Gets Things Done

Multi-Agent Collaboration · Organization Orchestration · Plugin System · Sandbox Security · 30+ LLMs · 6 IM Platforms · 89+ Tools · Desktop / Web / Mobile

Quick-Start • Org Orchestration • Scan-to-Bind • Plugins • Security • Docs

English | 中文

What is OpenAkita?

Other AIs just chat. OpenAkita gets things done.

OpenAkita is an open-source, all-in-one AI assistant — multiple AI Agents work together, build an AI company that runs autonomously, search the web, operate your computer, manage files, run scheduled tasks, and respond instantly across Telegram / Feishu / WeCom / DingTalk / QQ. Scan a QR code to bind your chat app in 30 seconds. It remembers your preferences, teaches itself new skills, and never gives up on a task. Extend anything through the plugin system, protected by 6-layer sandbox security.

Fully GUI-based setup. Ready in 5 minutes. Zero command line required.

🌐 Website openakita.ai  |  📥 Download Desktop App  |  📖 Documentation  |  💬 Discord Community

Quick-Start Guide

🚀 For First-Time Users (3 Minutes)

No installation required — download the desktop app and start chatting:

1. Download the installer from GitHub Releases
2. Install and follow the onboarding wizard
3. Enter your API Key (get one from Anthropic or DeepSeek)
4. Try your first task: Type "Create a calculator" and watch it work

💻 For Developers (5 Minutes)

# Install
pip install openakita[all]

# Quick setup (interactive wizard)
openakita init

# Run your first task
openakita run "Build a weather scraper"

✨ What You Can Do Right Away

➡️ Next Steps

• Configure LLM: Add multiple providers for automatic failover
• Set up IM channels: Scan QR code to bind WeChat/Feishu/WeCom in 30 seconds
• Explore skills: Install from marketplace or create your own
• Try org mode: Build an AI company and watch it run
• Join community: Discord | WeChat Group

Core Capabilities

Full Feature List

5-Minute Setup

Option 1: Desktop App (Recommended)

Fully GUI-based, no command line — this is what sets OpenAkita apart from other open-source AI assistants:

• No Python installation, no git clone, no config file editing
• Isolated runtime — won't mess with your existing system
• Chinese users get automatic mirror switching
• Models, IM channels, skills, schedules — all configured in the GUI

Download: GitHub Releases — Windows (.exe) / macOS (.dmg) / Linux (.deb)

Learn more at openakita.ai

Option 2: pip Install

pip install openakita[all]    # Install with all optional features
openakita init                # Run setup wizard
openakita                     # Launch interactive CLI

Option 3: Source Install

git clone https://github.com/openakita/openakita.git
cd openakita
python -m venv venv && source venv/bin/activate
pip install -e ".[all]"
openakita init

Commands

openakita                              # Interactive chat
openakita run "Build a calculator"     # Execute a single task
openakita serve                        # Service mode (IM channels)
openakita serve --dev                  # Dev mode with hot reload
openakita daemon start                 # Background daemon
openakita status                       # Check status

Multi-Platform Access

OpenAkita supports Desktop, Web, and Mobile — use it anywhere, on any device:

Desktop App

Cross-platform desktop app built with Tauri 2.x + React + TypeScript:

Dark/light theme · Onboarding wizard · Auto-update · Bilingual (EN/CN) · Start on boot

Mobile App

_{▶ Click to watch the Mobile App demo on Bilibili}

• Connect your phone to the desktop backend over local network
• Full-featured: chat, multi-Agent collaboration, memory, skills, MCP — all on mobile
• Supports real-time streaming and Thinking chain display
• Preview mode available without connecting to a server

Organization Orchestration

_{▶ Click to watch: Built a company on OpenAkita, and it runs autonomously (Bilibili)}

Beyond multi-Agent collaboration — build an entire AI company. OpenAkita includes a full organization orchestration engine (AgentOrg) that lets you visually design company structures in the GUI, where AI agents operate like a real company:

┌───────────────────────────────────────────────┐
│                CEO / Executive                 │
│       Sets company strategy, coordinates all   │
└───┬───────────┬───────────┬───────────┬───────┘
    ▼           ▼           ▼           ▼
  CTO        Product     Marketing     CFO
 Tech arch   Planning    Strategy    Budget ctrl
    │           │           │           │
    ▼           ▼           ▼           ▼
 Dev team    Design      Content      Analytics

Key Features

Multi-Agent Collaboration

_{▶ Click to watch the Multi-Agent collaboration demo on Bilibili}

OpenAkita has a built-in multi-Agent orchestration system — not just one AI, but an AI team:

You: "Create a competitive analysis report"
    │
    ▼
┌──────────────────────────────────────┐
│      AgentOrchestrator (Director)     │
│   Decomposes task → Assigns to Agents │
└───┬────────────┬──────────────┬──────┘
    ▼            ▼              ▼
 Search Agent  Analysis Agent  Writing Agent
 (web research) (data crunching) (report drafting)
    │            │              │
    └────────────┴──────────────┘
                 ▼
         Results merged, delivered to you

• Specialization: Different Agents for different domains, auto-matched to tasks
• Parallel Processing: Multiple Agents work simultaneously
• Auto Handoff: If one Agent gets stuck, it hands off to a better-suited one
• Failover: Agent failure triggers automatic switch to backup
• Depth Control: Max 5 delegation levels to prevent runaway recursion
• Visual Tracking: Agent Dashboard shows real-time status of every Agent
• Instance Pooling: Agent instance pool with LRU eviction for efficient resource use

IM Scan-to-Bind

_{▶ Click to watch: OpenAkita scan-to-bind for WeChat, Feishu, WeCom (Bilibili)}

No developer account needed. No callback URL configuration. No technical knowledge required — scan a QR code, 30 seconds to bind:

Once bound, just @AI in your chat app — send messages, images, files, voice — AI handles it all.

6 IM Platforms

Talk to your AI right inside the chat tools you already use:

• 📷 Vision: Send screenshots/photos — AI understands them
• 🎤 Voice: Send voice messages — auto-transcribed and processed
• 📎 File Delivery: AI-generated files pushed directly to chat
• 👥 Group Chat: Replies when @mentioned, stays quiet otherwise
• 💭 Chain-of-Thought: Real-time reasoning process streamed to IM
• 🔄 Message Interrupts: Insert new instructions between tool calls without waiting

Plugin System

OpenAkita provides a complete plugin architecture with plugin.json manifest declarations, a 3-tier permission model for security, and 10 lifecycle hooks for deep integration:

8 Plugin Types

3-Tier Permission Model

Lifecycle Hooks

on_init → on_message_received → on_tool_result → on_prompt_build → on_retrieve → on_session_start → on_session_end → on_schedule → on_shutdown

Plugins have automatic fault isolation: error count exceeding threshold triggers auto-disable, preventing a single plugin from crashing the system.

Bundled AI-Media Plugins (20)

Built on the openakita-plugin-sdk (contrib/ 6 modules: verification, quality_gates, intent_verifier, provider_score, error_coach, slideshow_risk / source_review). All ship with SKILL.md + README.md + tests.

Developer docs: Plugin System Overview · SDK contrib catalog · Sprint 18 Cleanup Assessment

Sandbox Security

OpenAkita implements a 6-layer defense-in-depth security model, from path management to OS-level isolation:

L1  Path Zoning         workspace / controlled / protected / forbidden
L2  Confirmation Gate   Dangerous ops (delete files, system commands) require user approval
L3  Command Intercept   regedit, format, rm -rf — blocked outright
L4  File Snapshots      Auto-checkpoint before writes, rollback available
L5  Self-Protection     data/, src/, identity/ — core dirs locked from modification
L6  OS-Level Sandbox    Linux bwrap / macOS seatbelt / Windows MIC

Sandbox Execution

When the policy engine classifies a shell command as HIGH risk, it automatically runs in an OS-level sandbox:

Additional Security Mechanisms

• Policy Engine: POLICIES.yaml for tool permissions, shell command blocklist, path restrictions
• Resource Budgets: Token / cost / duration / iteration / tool call limits per task
• Runtime Supervision: Auto-detection of tool thrashing, reasoning loops, token anomalies
• Local Data: Memory, config, and chat history stored on your machine only
• Open Source: AGPL-3.0-only, fully transparent codebase

30+ LLM Providers

No vendor lock-in. Mix and match freely:

7 capability dimensions: Text · Vision · Video · Tool use · Thinking · Audio · PDF

Smart failover: One model goes down, the next picks up seamlessly.

Recommended Models

International Models (in order of recommendation):

Chinese Models (recommended):

For complex reasoning, enable Thinking mode — add -thinking suffix to the model name.

⚠️ Local small models not recommended (e.g. 7B/14B quantized): Small models have limited tool-calling and agent collaboration capabilities, prone to hallucinations and format errors. Use API-hosted flagship models for the best experience.

Memory System

Not just a "context window" — true long-term memory. Supports dual modes with automatic switching:

Mode 1: Fragment Memory (Classic)

• Three layers: Working memory (current task) + Core memory (user profile) + Dynamic retrieval (past experience)
• 7 memory types: Fact / Preference / Skill / Error / Rule / Persona trait / Experience
• Multi-path recall: Semantic + full-text + temporal + attachment search
• Gets smarter over time: Preferences you mentioned two months ago? Still remembered.

Mode 2: MDRM Relational Graph Memory (New)

On top of fragment memory, builds causal chains, timelines, and entity relationship graphs — letting AI truly understand connections between events:

• 4 node types: Event / Fact / Decision / Goal
• Multi-hop graph traversal: Starting from seed nodes, expands along relationship edges to find deep connections
• 3-layer encoding: Fast rule-based encoding → summary backfill → session-end batch LLM encoding
• 3D visualization: Frontend supports 3D visualization of the memory graph

Smart Mode Switching

Set memory_mode to auto (default) and the system auto-routes based on query characteristics: causal/timeline/cross-session questions use Mode 2 graph traversal, preference/fact queries use Mode 1 semantic retrieval.

• AI-driven extraction: Automatically distills valuable information after each conversation, dual-track writes to both modes
• 3D memory graph: Visualize memory nodes and relationships, intuitively understand AI's memory structure

MCP Integration

OpenAkita includes a full MCP (Model Context Protocol) client, enabling AI to connect with any external service:

Connect to GitHub, databases, Playwright browser, filesystem, or any MCP Server.

Self-Evolution

OpenAkita keeps getting stronger:

Daily 04:00   →  Self-check: analyze error logs → AI diagnosis → auto-fix → push report
After failure →  Root cause analysis (context loss / tool limitation / loop / budget) → suggestions
Missing skill →  Auto-search GitHub for skills, or AI generates one on the spot
Missing dep   →  Auto pip install, auto mirror switching for China
Every chat    →  Extract preferences and experience → long-term memory

Architecture

Desktop App (Tauri + React)
    │
Identity ─── SOUL.md · AGENT.md · POLICIES.yaml · 8 Persona Presets
    │
Core     ─── ReasoningEngine(ReAct) · Brain(LLM) · ContextManager
    │        PromptAssembler · RuntimeSupervisor · ResourceBudget
    │
Agents   ─── AgentOrchestrator(Coordination) · AgentInstancePool(Pooling)
    │        AgentFactory · FallbackResolver(Failover)
    │
Org      ─── OrgRuntime(Runtime) · OrgManager(CRUD)
    │        OrgMessenger(Routing) · Blackboard(Shared Memory)
    │        OrgIdentity(Inheritance) · OrgPolicies(Policies)
    │
Plugins  ─── PluginManager(Discovery/Loading) · PluginAPI(Host Interface)
    │        HookRegistry(10 Hooks) · PluginSandbox(Fault Isolation)
    │
Memory   ─── Mode1: UnifiedStore(SQLite+Vector) · RetrievalEngine(Multi-path)
    │        Mode2: RelationalStore(MDRM Graph) · GraphEngine(Multi-hop)
    │        MemoryModeRouter(Auto Switch) · MemoryEncoder(3-Layer)
    │
Tools    ─── Shell · File · Browser · Desktop · Web · MCP · Skills
    │        Plan · Scheduler · Sticker · Persona · Agent Delegation
    │
Security ─── PolicyEngine(6-Layer) · SandboxExecutor(OS Sandbox)
    │        ConfirmationGate · CommandFilter · Checkpoint
    │
Evolution ── SelfCheck · FailureAnalyzer · SkillGenerator · Installer
    │
Channels ─── CLI · Telegram · Feishu · WeCom · WeChat · DingTalk · QQ · OneBot
    │
Tracing  ─── AgentTracer(12 SpanTypes) · DecisionTrace · TokenStats

Documentation

Community

WeChat Official Follow for updates

WeChat (Personal) Note "OpenAkita" to join group

WeChat Group Scan to join (⚠️ refreshed weekly)

QQ Group: 854429727 Scan or search to join

🌐 Website · 💬 Discord · 🐦 X (Twitter) · 📧 Email

Issues · Discussions · ⭐ Star

Acknowledgments

• Anthropic Claude — Default recommended LLM, core development partner
• Tauri — Cross-platform desktop framework
• ChineseBQB — 5700+ stickers that give AI a soul
• browser-use — AI browser automation
• AGENTS.md / Agent Skills — Open standards

Community Contributors

• @948324394 — Docker deployment support

License

OpenAkita source code is licensed under the GNU Affero General Public License v3.0 only (AGPL-3.0-only) — See LICENSE.

The OpenAkita name, logos, icons, screenshots, and other brand assets are not licensed under AGPL-3.0-only. See TRADEMARK.md for brand usage rules.

Third-party licenses: THIRD_PARTY_NOTICES.md

Star History

OpenAkita — Open-Source Multi-Agent AI Assistant That Gets Things Done
openakita.ai