Orkas: Local-First Multi-Agent AI Desktop App

What Orkas is

Orkas is an open-source, local-first multi-agent desktop app. Instead of a single chatbot, it gives you a Commander: you describe a goal in one chat, and the Commander plans the work, handles general parts itself, and coordinates specialist agents in parallel or in sequence. The README's example is a request to research five competitors, write it up and turn it into a deck: one agent gathers and verifies sources, another drafts the report, a third builds the slides, and the finished files land on your disk.

The project targets people who want a team of agents rather than one assistant, a desktop GUI with file drop-in and visual agent management, and data, keys and agents kept on their own machine rather than in a vendor cloud. The README is equally direct about who it is not for: anyone who just wants a single all-purpose chatbot, a fully hosted team, or a code library to embed in their own application.

Orkas runs on macOS, Windows and Linux, is written mainly in JavaScript and TypeScript on Electron, and is MIT licensed. You bring your own model keys; the README lists Claude, OpenAI, Gemini, DeepSeek, Kimi, GLM, Qwen, MiniMax and Doubao, plus OpenAI- or Anthropic-compatible local endpoints.

How it works

The Commander is the only actor that holds dispatch tools; workers and agents have none. It chooses between three verbs, and the choice decides who the user hears from:

• hand_off_to passes the conversation to an agent and ends the Commander's turn, so the agent's reply stands as the answer.
• dispatch_to shows the agent's reply to the user and returns the result to the Commander, which continues with a named next step.
• run_worker runs a private task whose result returns only to the Commander. Several run_worker calls in one response run concurrently.

The Commander must name a concrete next action before it may use dispatch_to. If all that is left is restating the agent's reply, the rule forces hand_off_to. According to the README, that one constraint is what stops multi-agent chats from ending in a redundant re-summary of something the user already read.

Bounded concurrency

Each conversation has one FIFO runtime, and top-level turns run through it serially. Parallelism happens inside a turn as nested in-process dispatch. Two semaphores bound it: a global limit of 10 slots and a nested-dispatch limit of 4, configurable through ORKAS_MAX_DISPATCH_CONCURRENCY. Nested runs skip the global semaphore because the parent already holds a slot; the README explains that this is deadlock-free by construction, since only the Commander can dispatch.

Context budget derived from the model

Compaction thresholds are computed from the active model's context window and output limit rather than fixed numbers, so the same policy applies to a 32K model and a 1M one. Every trigger is a share of a message budget (0.3 for in-turn history, 0.2 for cross-turn history, 0.1 for one round's inline tool results). A run can compact as often as needed, but a fingerprint check refuses to compact identical state twice, a minimum-savings threshold rejects low-value passes, and three consecutive failures stop LLM-backed compaction. A workspace ledger of files written, files read and commands run survives compaction, so agents do not lose track of work they already did.

Local memory

Knowledge bases are SQLite indexes built on your machine, combining FTS5 full-text search with stored vectors. Queries run both ways and the results merge by reciprocal rank fusion, weighted 0.7 vector to 0.3 keyword. Embeddings are computed on device by a bundled ONNX model (bge-small-zh-v1.5, about 95 MB, downloaded once), so indexing sends nothing off the machine. Cloud embedding providers such as OpenAI, Gemini, Voyage and Mistral are available as an option.

Key features

• Nine built-in specialists. DeepResearcher, ContentWriter, PptMaker, ProductDeveloper, OfficeWorker, VideoStudio, ImageStudio, UIDesigner and SeoGeoAgent ship with the app, out of 30 agents in the Orkas marketplace.
• External CLI agents as sessions. Orkas can drive Claude Code, Codex and OpenCode, plus the personal agents OpenClaw and Hermes-Agent, as local subprocesses directed from the same chat.
• Local tools. Open-source projects such as HyperFrames can be onboarded as local tools the Commander can call.
• Mix providers per agent. One agent can run on Claude, another on DeepSeek and another on a local endpoint.
• Self-evolution. Each agent keeps competence and learning-strategy notes that feed its next system prompt. Reflection is triggered by weighted signals such as error recovery or user correction, not after every task, and agents can save a working method as a private SKILL.md.
• Runaway guards. A 100-turn ceiling for workers, per-turn tool-round limits (120 for the Commander, 100 for named agents), loop detection for repeated tool calls, and an idle watchdog for stalled turns.
• Custom agents. You can describe what you need and the Commander builds a custom agent.

Getting started

Packaged installers are available for macOS (Apple Silicon and Intel) and Windows 10+ from the project website. On Linux, Orkas currently runs from source. The source bootstrap needs Node 22.12 or later and macOS, Windows 10+ or glibc 2.34+ Linux on x64 or arm64:

git clone https://github.com/Orkas-AI/Orkas.git
cd Orkas
./run.sh           # macOS / Linux
run.cmd            # Windows

On first launch the script installs the locked npm dependencies and prepares a pinned Python, uv, Node, the embedding model, OfficeCLI, FFmpeg, whisper.cpp and a multilingual speech model. It creates a workspace under ~/.orkas/ on macOS and Linux. After that, open Settings → AI Providers to add an API key or OAuth login.

If native modules fail, the README recommends Node.js 24 LTS and a repair command, with a separate command that only checks:

npm run native:repair
npm run native:check

To use a local model through Ollama or LM Studio, add a custom model under Account settings → Models → Chat, choose OpenAI-compatible or Anthropic-compatible, and enter the base URL, exact model ID and key.

Use cases

• Recurring reports and market research. A research agent gathers and summarises sources and ships a weekly report with citations.
• Turning a spec into tasks. The Commander breaks a PRD into tasks and dispatches them, with ProductDeveloper handling repo-aware implementation, bug fixes and review.
• Working with local documents. Drop files into a knowledge base and query them without the data leaving the machine, apart from the model calls you choose to make.
• Mixed deliverables. One chat can produce code, research, slide decks and video by combining built-in agents with CLI agents and local tools.
• Orchestrating existing coding agents. Teams already using Claude Code or Codex can run them as sessions under one Commander instead of juggling terminals.

How it compares

The README positions Orkas against several categories. LangChain and CrewAI are code-first frameworks where you define agents and orchestration in Python or JavaScript; Orkas is a desktop app you direct through chat. Cloud agent platforms keep conversations, files and keys on vendor infrastructure; Orkas keeps them on disk and sends model calls straight to the provider. OpenClaw and Hermes-Agent are single personal agents; Orkas uses them as CLI backends under its Commander rather than replacing them. Against single-assistant desktop apps, the difference is the team model: one coordinator plus specialists with their own skills and memory. These are the project's own framings; how they hold up depends on your workload and models.

Things to know before adopting

• Licence. The app is MIT licensed and free to use with your own keys.
• Optional paid model. The packaged desktop app offers a built-in Orkas model billed in credits for people who do not want to manage API keys. It is opt-in.
• Account on packaged builds. The packaged app asks you to sign in on first launch. The source build has no account layer and boots straight into the app.
• Data flow. Data stays local, but any remote model or tool you select receives the content needed for that task.
• Platform limits. Linux has no installer yet and needs glibc 2.34+. Alpine and other musl-based distributions are not supported.
• Heavy first launch. The bootstrap downloads several runtimes and models, including an embedding model of about 95 MB. Plan for disk space and time on first run.
• Young project. The repository was created in April 2026, so expect fast change between releases.

Project activity

As of October 2026 the repository has about 2,200 stars and around 90 forks, with commits pushed in mid-October 2026. It was created on GitHub in April 2026, its primary language is JavaScript, and it is released under the MIT licence. The source is at github.com/Orkas-AI/Orkas, and installers, agent docs and pricing for the optional hosted model are on orkas.ai.