mux-swarm

Quickstart »  ·  Docs  ·  Commands  ·  Configuration  ·  Examples  ·  Architecture

---

Demo

https://github.com/user-attachments/assets/3c40809c-93d9-4b8b-b090-736546a6461f

See more in action: the Examples and Demos page has video walkthroughs of parallel swarm execution, autonomous runs, and real-world use cases.

Highlights

Not just a coding tool. Mux-Swarm operates your computer the way you would: research, refactor, run pipelines, watch files, hit APIs, drive your editor, and talk to other machines. Anything you can do on your machine, an agent can do here, and with a little configuration, much more.

• An OS for agents, in one binary. TUI, web server, scheduling daemon, native tools, and sandbox drivers ship in a single static binary. Built in C#. No Python, no node_modules, no venv, nothing to install.
• Agents that operate the real machine. Native in-process REPL, shell, and file tools with per-sub-agent scope isolation, no MCP subprocess forked per call.
• One main agentic interface, multiple execution styles. Start with /agent: a continuing lead session that can work directly or delegate specialists. Delegation-enabled /ultra, /giga, and team leads can match or exceed swarm-mode coordination; /swarm and /pswarm remain specialized serial and concurrent-batch interfaces, not capability upgrades.
• Explicit reasoning effort. Shift+Tab cycles low → med → high → xhigh → max. Use /effort xhigh, /effort max (or /max), or /effort custom <raw-value> for a provider-specific value. Max/custom are sent literally, without silent fallback. See the command reference.
• Pick your blast radius. A pluggable sandbox runs commands bare, in Docker Sandboxes microVMs, Docker or Podman containers, or behind gVisor and Kata, switchable per session with /sandbox and a deny-by-default network allowlist.
• Memory that compounds. Layered memory (behavioral, factual, knowledge graph, vector) plus an opt-in deep-reflection mode that distills each session and injects it back, mid-turn and across runs.
• Sign in with the subscriptions you already have. A bundled proxy signs into Claude, Codex, Kimi, xAI, or Antigravity with /login, no API keys in config. Any OpenAI-compatible provider works too.
• Runs while you sleep. A built-in daemon fires whole multi-agent pipelines on cron, file-watch, status, or webhook triggers, with OS service registration for always-on hosts.
• A web UI from the same binary. --serve gives live agent streams, a node graph, and session management behind your own auth, plus an HTTP and WebSocket API to drive it from anything.
• Pair on a live session. /share streams your session to teammates you approve, end-to-end encrypted, and can let them type prompts while you keep control (Ctrl+] takes it back).
• MCP-native, in your editor too. Attach any MCP server to any agent, extend with a hot-reloadable skills system, and connect from Zed over ACP.

Quickstart

Prerequisites: an OpenAI-compatible LLM provider (or subscription sign-in via /login), Node/npx for Node-based MCP servers, and uv/uvx for Python-based MCP servers. See the Install guide for the full matrix and caveats.

Install (Linux / macOS):

curl -fsSL https://www.muxswarm.dev/install.sh | bash

Install (Windows, PowerShell):

irm https://www.muxswarm.dev/install.ps1 | iex

First run:

mux-swarm                 # interactive TUI
mux-swarm --serve         # embedded web UI at http://localhost:6723
mux-swarm --goal "Summarize the shareholder data in my sandbox and save a report"

On first launch the /setup wizard walks you through configuration. The easiest path is subscription sign-in with /login. At the interactive menu, start with /agent, then enter your task; use /swap to choose its lead. New here? Follow the Getting Started tutorial.

About

Mux-Swarm is a configurable agentic operating system that runs alongside your OS. Its primary /agent interface sits on an execution environment for AI agents, with process management, crash recovery, multi-tenant isolation, layered memory, and a workflow engine.

Out of the box it ships specialized agent definitions for research, coding, analysis, automation, and system operations. Choose a lead for the main /agent interface and enable the delegation/team capabilities you need, or choose dedicated serial (/swarm) or concurrent-batch (/pswarm) coordination for a particular execution style. The real versatility comes from the configuration-driven architecture: define custom swarms, agent roles, prompts, MCP servers, skills, and execution policies entirely through config files. Swap providers, redesign topologies, or adapt the runtime for anything from personal workflows to enterprise pipelines, all without modifying code.

Documentation

Full documentation lives in docs/.

Get started

• Install - install script, build from source, prerequisites, service registration
• Getting Started - a short first-run tutorial
• Setup Guide - full first-time configuration and messaging bridges
• Examples - mode-by-mode demos

Reference

• CLI and Commands - every CLI flag and slash command
• Configuration - full config.json and swarm.json schema
• Serve and API - web UI, HTTP /api, and /ws protocol

Guides and concepts

• Workflows - deterministic workflow files
• Session Sharing - /share + /join live, encrypted session sharing
• Hooks, Webhooks, and Daemon - lifecycle hooks and automation triggers
• Sandbox and Security - execution backends and production posture
• ACP - Zed editor integration
• Architecture - orchestration lifecycle and design invariants
• Memory - layered and deep-memory systems

Architecture at a glance

The main /agent interface owns a continuing lead conversation and can enlist specialists when enabled. Dedicated /swarm and /pswarm coordinators offer serial specialist dispatch and concurrent batches respectively; these are different coordination styles, not higher capability tiers. Agents interact with the world through MCP tools, native Filesystem and Shell/REPL tools, and dynamically loaded skills. State persists across restarts through serializable sessions and a layered memory system. For the full picture, see Architecture and Memory.

Protocols and standards

Mux-Swarm is MCP-native and provider-agnostic. It speaks the OpenAI-compatible API, the Model Context Protocol, the Zed Agent Client Protocol, and the Agent Skills (SKILL.md) format. It is built on .NET 10, Microsoft.Extensions.AI, and Microsoft.Agents.AI.

Roadmap

Up next: additional platform bridges (Slack, Matrix, Signal), expanded OpenTelemetry coverage.

Recent releases include teams and subscription sign-in, native tools and pluggable sandboxing, the live TUI with full mouse control, the workflow engine, daemon mode, and event hooks. See the GitHub releases for details.

Contributing

Contributions are welcome. See CONTRIBUTING.md for guidelines, or open an issue to discuss.

License

Licensed under the GNU General Public License v3.0. See LICENSE for details.