v0.12.1 - Teams, Subscription Sign-In & Native Tools

Define your config.
Launch your swarm.

A CLI-native, cross-platform agent runtime for multi-agent orchestration, parallel execution, and tool-native AI operations. Any provider. Any OS. Your rules.

macOS / Linux
Windows
$ curl -fsSL https://www.muxswarm.dev/install.sh | bash
or build from source · requires .NET 10
Capabilities

What it does

Not an agentic chat. A configurable execution environment for AI agents.

⟐
Multi-Agent Orchestration
Orchestrator delegates to specialized agents by role. Each agent has scoped tools, models, and permissions. Config-driven, no code changes.
⫶
Parallel Execution
Decompose goals into independent subtasks and dispatch them concurrently. Research 8 companies simultaneously. Batch-process documents in parallel.
⊞
MCP-Native Tools
Model Context Protocol for tool integration. Filesystem, web search, databases, code execution: any MCP server works. Per-agent scoping.
⟁
Skills System
Agents discover and load operational playbooks at runtime. Keep prompts lean. Extend capabilities without code changes. Hot-reload on the fly.
↻
Continuous & Autonomous
Goal-driven loops with configurable intervals. Watchdog process for crash recovery. Session state persistence across restarts.
⊘
Scoped Isolation
Per-user or per-environment instances via config overrides. Filesystem allowlists. Sandboxed Docker execution. Multi-tenant ready.
◇
Any LLM Provider
OpenAI-compatible endpoints. OpenRouter, Ollama, LiteLLM, vLLM, direct APIs. Per-agent model routing with runtime swapping.
⊡
Layered Memory
In-context compaction, semantic vector search, structured knowledge graph, and filesystem artifact exchange. Agents remember across sessions.
⧉
Embeddable
Standalone binary. Machine-readable stdio mode. Config-driven behavior. Embed into backend services, CI/CD pipelines, or products.
⌁
Editor Integration (ACP)
Native Agent Client Protocol adapter. Drive the full swarm from Zed and other ACP editors, with model selection and streaming tool output.
⎏
Native REPL & Shell
Built-in persistent Python REPL and shell execution as first-class tools. Long-running jobs, live input, and per-agent isolation without external MCP servers.
⧟
Subscription Sign-In
Authenticate with existing Claude and Codex subscriptions via OAuth. Run on your plan, no per-token API billing, alongside any OpenAI-compatible endpoint.
Execution

Five ways to run

/swarm
Sequential
Multi-step goals with orchestrator-managed handoffs
/pswarm
Parallel
Independent subtasks dispatched concurrently
/agent
Single Agent
Direct back-and-forth with one specialist
--goal
CLI Fire & Forget
Automation, scripts, pipelines - no interaction
--continuous
Autonomous Loop
Long-running with watchdog and state recovery
Architecture

Configuration, not code

Two config files control everything. Swap providers without redesigning the swarm. Redesign the swarm without changing infrastructure.

Config.json - Infrastructure
Where and how agents connect
LLM providers, MCP server definitions, filesystem boundaries, Docker posture, and user identity. The wiring layer.
"llmProviders": [{ "name": "openrouter", ... }]
"mcpServers": { "Filesystem": { ... } }
"filesystem": { "allowedPaths": ["/project"] }
Swarm.json - Topology
Who does what
Agent roles, model routing, per-agent model tuning, delegation permissions, tool scope, and skill patterns. The behavior layer.
"agents": [{ "name": "CodeAgent",
  "model": "openai/gpt-5.5",
  "mcpServers": ["Filesystem", "PythonRepl"] }]
Prompts - Behavior Contracts
How agents think
Markdown files defining reasoning patterns, workflows, and constraints per role. Tune behavior without touching the runtime.
Prompts/Agents/orchestrator.md
Prompts/Agents/code_agent.md
Prompts/Agents/research_agent.md
Skills - Runtime Playbooks
What agents know
Reusable modules loaded at runtime via list_skills / read_skill. Extend capabilities without prompt bloat. Hot-reload with /reloadskills.
Skills/training-pipeline/SKILL.md
Skills/dataset-prep/SKILL.md
Skills/gpu-monitor/SKILL.md
Case Study - Autonomous Model Training
A swarm that researched, generated data, trained, self-recovered, and iterated, from a single goal file.
A multi-agent swarm autonomously researched the GPU/HPC domain, generated its own training dataset via frontier model distillation, self-recovered through four consecutive code failures, fine-tuned a 14B parameter model on rented GPU hardware, and began iterating to improve. Zero human intervention after launch.
<$11
Total cost
14B
Parameters
4
Self-recoveries
0
Human interventions
Read the full case study →
Standards

Built on open protocols

OpenAI Compatible API
Any endpoint exposing /v1/chat/completions works. Tested with OpenRouter, Ollama, LiteLLM, vLLM, and direct provider APIs.
Model Context Protocol
Native dual-transport MCP (stdio + HTTP/SSE). Dynamic tool discovery. Per-agent server scoping. Strict-mode validation.
Microsoft.Extensions.AI
Provider-agnostic IChatClient abstraction. Streaming, tool invocation, and per-agent model tuning via ChatOptions.
Session Serialization
Full round-trip session persistence. Resume across restarts. Automatic state intervals. Portable session files.

The ceiling is yours.

Define your config. Write your prompts. Point it at a goal. Walk away.

View on GitHub Quick Start Case Study