M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
O

Orkas

Community
Open-source, local-first multi-agent AI desktop client — command your AI agent team with chat.
How to install ↓ Compare GitHub source repository ↗
Category
Other #142 of 230
Stars
★ 2.2k Very popular
Transport
stdio (local process)
Runtime
Node.js 20+ · Prebuilt binary
Credentials
Optional API key
License
MIT
Last commit
Tools
6
51FMRS · D

Orkas is an open-source, local-first multi-agent desktop app: a Commander plans and dispatches work, nine specialist agents ship ready to use, and you bring your own model keys or local endpoint while data and keys stay on your machine. It also positions itself around MCP client capabilities, coordinating external CLI coding agents and open-source tools. It is a good fit for people who want a local agent team, and a poor fit for those who want a single chatbot, a pure code framework, or a fully hosted cloud team. The main risks are locally stored keys, the broad permission scope of running external subprocesses, and the Linux run-from-source constraint.

Strongest · Documentation 12/20 Weakest · Reliability 8/20

Reliability
8/20
Security and permissions
10/20
Maintenance
11/20
Documentation
12/20
Setup experience
10/20
Why each score
Reliability 8/20
Assessment is based solely on the static README and description. The README documents substantive internal mechanisms (a single FIFO runtime, paired globalSlots/dispatchSlots semaphores, a model-derived context budget formula, hybrid retrieval, four runaway guards, signal-triggered self-evolution) and cites concrete files such as bus.ts, context-budget.ts, workspace-state.ts, metacognition.ts, and actor-budgets.ts, which indicates deliberate design of key paths. However, no MCP server manifest is cached at the repository root, and there is no verifiable evidence of a clean startup or of the init + tool-list handshake. No CI workflows or committed tests covering the server's key paths are present, so the static calibration caps this dimension at 12; scored 8, deducted for the absence of reproducible execution evidence and error-path testing.
Security and permissions 10/20
The README states a local-first design: conversations, files, API keys, knowledge bases, and custom agents remain on disk, model calls go straight from the local machine to the provider and are never proxied or archived by Orkas, local models (Ollama/LM Studio) can be attached via an OpenAI-compatible endpoint, and embeddings are computed on-device by a bundled ONNX model (bge-small-zh-v1.5). That aligns with least privilege and clear data boundaries. Offsetting factors: the repository root offers no MCP manifest, so tool-level permission scopes and confirmation behavior for dangerous operations cannot be verified; the app drives external CLI coding agents (Claude Code, Codex, OpenCode, Cline) as local subprocesses, a potentially high-privilege side-effect surface whose confirmation and isolation policy is not described; and the packaged app prompts for sign-in on first launch. No malware, credential theft, covert exfiltration, or unconfirmed irreversible defaults were found, so no red line (0-4) is triggered, but given the missing tool-scope inventory and confirmation flow, a conservative 10 is assigned.
Maintenance 11/20
The MIT license is explicit, the README carries release/download badges and an update entry point, and the project reports 30 marketplace agents, 1852 stars, 13 open issues, and a non-archived state, indicating active maintenance with clear organizational ownership (Orkas-AI, author X @leochenpm). What cannot be seen from the supplied material is commit history, release cadence, dependency-update practice, and a security-response channel (e.g., SECURITY.md or a CVE process). Governance and versioning gaps remain, matching the 'active but governance/versioning gaps' anchor, so 11.
Documentation 12/20
Documentation is comparatively thorough: the install section separates packaged installers from source runs; lists Node 20+, macOS/Windows 10+/glibc 2.34+ Linux, and explicitly rules out Alpine/musl; explains that first launch fetches and verifies many pinned resources (uv, Node, ~95 MB embedding model, OfficeCLI, FFmpeg, whisper.cpp, multilingual speech model); documents the workspace path; notes on-demand installs for OCR and skill-specific Python packages; and provides an FAQ on local models, key storage, offline capability, account requirements, platform support, and pricing. Deductions: there are no concrete MCP client configuration examples, no detailed tool-parameter inventory or limits, thin troubleshooting content, and a notable share of the document is marketing comparison and outbound links that carry limited independent evidentiary weight.
Setup experience 10/20
The install path is broadly clear: packaged installers for macOS and Windows, source build for Linux via git clone plus ./run.sh or run.cmd, with first-launch preparation of the locked npm tree, Python/uv/Node, embedding model, OfficeCLI, FFmpeg, whisper.cpp, and speech model, plus an Electron-ABI check of platform-native modules. The bar is nonetheless high: Node 20+ is required, complex native dependencies may need Python 3 and a C/C++ toolchain, the first-launch download is large and of uncontrolled duration, and Linux has no installer and no musl support. More decisively, no MCP manifest is cached and there is no configuration example showing a working connection in a mainstream MCP client, so the final 'working connection' step cannot be statically verified; under the static calibration cap of 15, this scores 10.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesWrites / deletes local filesRuns commands or codeUses the network

Best for

  • People who want a team of specialist agents coordinated by a Commander rather than a single chatbot
  • Users who insist their data, keys, and agents stay on their own disk instead of a vendor cloud
  • Users who want to mix multiple model providers or local model endpoints
  • Users who want agents with private skills and memory that improve through reflection

Not for

  • People who just want a single all-purpose chatbot
  • Users who want a fully hosted/cloud multi-agent team and don't mind their data living on a vendor's servers
  • Developers who want a pure code library to embed in their own app (e.g. LangChain or CrewAI-style frameworks)
  • Users who cannot run Node 20+ or are on musl-based distributions such as Alpine

Required permissions

  • Read and write a local workspace directory (~/.orkas/ on macOS/Linux, <smallest non-system drive>:\.orkas\ on Windows)
  • Store conversations, files, knowledge bases, custom agents, and API keys on your local disk
  • Outbound network access to the model provider endpoints you configure (and to cloud embedding providers if you choose them)
  • Run external CLI coding agents (Claude Code, Codex, OpenCode, Cline) as local subprocesses
  • Download and verify local resources on first launch (embedding model ~95 MB, whisper.cpp runtime and multilingual speech model, FFmpeg, OfficeCLI, and others)

Risks and side effects

  • API keys are stored on your machine's disk and can be read by any process or person with access to that account or device, so OS account security and disk encryption matter
  • The Commander can drive external CLI coding agents and run them as local subprocesses, so a model may take actions with side effects; scope the working directory and permissions yourself
  • Building from source installs a large dependency tree and prepares native runtimes, making first launch long and network-dependent
  • On Linux, only glibc 2.34+ x64/arm64 is supported; Alpine and other musl-based distributions are not
  • The packaged desktop app asks you to sign in on first launch; avoiding any account layer means using the source build in this repository
  • The optional built-in Orkas model is billed by Orkas in credits, so paths other than your own keys incur additional cost

Setup

Before you start

Runtime：Node.js 20+ · Prebuilt binary

Other optional settings (1)
ORKAS_MAX_DISPATCH_CONCURRENCY optional Optional env var bounding nested dispatch concurrency (dispatchSlots, default 4).
  1. For packaged installers: download and install the macOS (Apple Silicon or Intel) or Windows x64 build from the official download page.
  2. To run from source (currently the way to run Orkas on Linux): ensure Node 20+, then run git clone https://github.com/Orkas-AI/Orkas.git, cd Orkas, and execute ./run.sh (macOS/Linux) or run.cmd (Windows).
  3. First launch installs the locked npm dependency tree and prepares the pinned Python, uv, Node, embedding model (~95 MB), OfficeCLI, FFmpeg, whisper.cpp, and multilingual speech model resources; Linux startup then verifies platform-native modules and the Whisper runtime under Electron's ABI before opening the app.
  4. First launch creates a workspace under ~/.orkas/ (macOS/Linux) or <smallest non-system drive>:\.orkas\ (Windows).
  5. Open Settings → AI Providers to add an API key or OAuth; for local models choose Custom (OpenAI-compatible) and point the base URL at your endpoint. Note: the source build has no account layer and boots straight into the app, while the packaged app asks you to sign in on first launch.

Check that it works

Launch Orkas and in a chat ask the Commander to run memory_search against a knowledge base, or watch it use hand_off_to/dispatch_to to route a task to a built-in specialist agent — a returned result confirms the tools are wired up.

Troubleshooting

  1. If the app won't start, verify Node 20+ (source build) and that the platform is macOS / Windows 10+ / glibc 2.34+ Linux x64 or arm64
  2. On Linux, native-module or Whisper runtime errors usually mean the glibc requirement is unmet; keep Python 3 and a C/C++ build toolchain available to rebuild native npm packages locally
  3. If model calls fail, check that your key or OAuth under Settings → AI Providers is valid; for local models confirm the Custom (OpenAI-compatible) base URL points to the right local endpoint
  4. Local speech transcription downloads and verifies the whisper.cpp runtime and multilingual model on first use, so a network-restricted environment disables that feature
  5. If knowledge base retrieval returns nothing, confirm the documents were chunked and indexed and that the embedding model (~95 MB) downloaded successfully
  6. OCR and skill-specific Python packages are installed into isolated local environments when those features are first used; if installation fails, the corresponding feature is unavailable

Things to try

Once connected, you can ask your AI assistant things like:

  • Research the top 5 competitors, write it up, and turn it into a deck
  • Break this product spec into dev tasks and dispatch them to ProductDeveloper
  • Search my knowledge base for what we recorded about the deployment process last session
  • Hand this repo off to Claude Code to fix the build error

Tools 6

hand_off_to writes
Commander hands the task to an agent and ends its turn; that agent's reply stands as the final answer the user sees.
dispatch_to writes
Commander dispatches a task to an agent; the agent's reply is visible to the user and the result returns to the Commander, which continues with a named next step.
run_worker writes
Commander dispatches an ephemeral sub-task with private input not shown to the user; the result returns to the Commander, which continues. Emitting several calls in one response runs them concurrently.
memory_search read-only
Search the local knowledge base index over stored documents and past sessions (FTS5 full text merged with vector similarity by reciprocal rank fusion).
memory_read read-only
Read document content from the local knowledge base index.
skill_manage writes
Crystallize "how I solved X" into a private SKILL.md that the agent can use from the next turn on.

Use cases

Automate recurring reports and market research, with a specialist agent gathering, summarizing, and shipping a weekly report
Turn a product requirement document (PRD) into dev tasks and dispatch them across agents
Chat with your documents and run local data analysis while keeping the data on your machine
Produce code, research, video, and slide decks from one chat, with the Commander driving open-source tools like HyperFrames and handing off to CLI coding agents (Claude Code, Codex, OpenCode, Cline)
Mix providers across agents — one agent on Claude, another on DeepSeek or a local endpoint

Overview

Orkas is an open-source, local-first multi-agent AI desktop client. You describe a goal; its Commander plans the work, handles the general parts itself, and coordinates specialist agents in parallel or in sequence. Nine specialist agents ship with the app (out of 30 in the marketplace), ready the moment you launch it. Bring your own model keys (Claude, OpenAI, Gemini, DeepSeek, Kimi, GLM, Qwen, MiniMax, Doubao) or point it at an OpenAI-compatible local endpoint. Conversations, files, knowledge bases, API keys, and custom agents all stay on your disk; model calls go straight from your machine to the provider and are never proxied or archived by Orkas. Each agent has its own private skills (SKILL.md) and memory and self-evolves through reflection and skill crystallization. macOS, Windows 10+, and glibc 2.34+ Linux x64/arm64 (Linux currently runs from source). MIT licensed.

Similar servers

BioMCP 75 · B

One binary. One grammar. Evidence from the biomedical sources you already trust.

★ 659 · Tools 11 Compare with this →
Compare with other MCP servers

Source revision 15bf64cfcad3 Data synced 2026-10-19 Read the FMRS scoring method