v0.5.0 — Parallel Swarm Execution

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

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

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.

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.4",
"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

Self-recoveries

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.