The Open-source AI Application Server

No one builds their own Nginx to deploy a website. No one should reinvent infrastructure to build AI.

MUXI V1: Deploy Intelligence

MUXI (/ˈmʌk.siː/) is the AI application server. Not a framework. Not a wrapper. A complete, self-hosted server stack where agents are native primitives and production capabilities are infrastructure, not application code.

Deploy complete agent formations with orchestration, auditable memory, group-based RBAC, tools, knowledge, proactive behavior, self-tuning, observability, and twelve SDKs already integrated.

[!IMPORTANT] MUXI V1 is the stable 1.x generation. The Server, Runtime, CLI, Formation API, Server API, and all twelve SDKs move together with coordinated contracts for authentication, streaming, errors, idempotency, and response envelopes.

Concept	Docker	MUXI
Engine	Docker Engine	Server + Runtime
Definition	Dockerfile	Formation
Registry	Docker Hub	MUXI Registry
CLI	`docker`	`muxi`

[!NOTE] MUXI introduced the Agent Formation Standard – an open specification for portable, declarative AI systems. A formation packages agents, knowledge, memory, tools, skills, workflows, triggers, policies, and operational behavior into one deployable unit.

Quick Start

Install:

brew install muxi-ai/tap/muxi                        # macOS
curl -fsSL https://muxi.org/install | sudo bash      # Linux
powershell -c "irm https://muxi.org/install | iex"   # Windows

Run:

muxi pull @muxi/hello-muxi   # pull a formation
muxi deploy                   # deploy it
muxi chat hello-muxi         # talk to it

Three commands. Your formation is running, stateful, and accessible through REST, SSE, MCP, and twelve SDKs.

📚 Docs: Quickstart | Installation

Build on Top with SDKs

from muxi import FormationClient

client = FormationClient(
    server_url="http://localhost:7890",
    formation_id="hello-muxi",
    client_key="<your-client-key>"
)

for chunk in client.chat_stream({ "message": "Hello!" }, user_id="user_123"):
    print(chunk.get("text", ""), end="")

Official SDKs are available for Python, TypeScript, Go, Ruby, PHP, C#, Java, Kotlin, Swift, Dart, Rust, and C++.

📚 Docs: SDKs | API Reference

How MUXI Compares

	MUXI	LangChain / LangGraph	CrewAI	AutoGen
What it is	Server infrastructure	Python libraries	Python framework	Multi-agent framework
Deploy	`muxi deploy`	Write your own	Write your own	Write your own
Configure	Declarative `.afs` files	Imperative code	Imperative code	Imperative code
Multi-tenancy	User isolation and per-user credentials	Application-owned	Application-owned	Application-owned
RBAC	Groups, inheritance, agents, MCP, and tool rules	Build it yourself	Build it yourself	Build it yourself
Memory	Layered, scoped, event-sourced platform	Compose your own	Task-oriented memory	Bring your own
Proactiveness	Heartbeats, channels, active hours, soul documents	Build it yourself	Build it yourself	Build it yourself
Tools	MCP indexed once and selected at runtime	Schemas enter application context	Schemas enter application context	Tool registration
Operations	Deploy, update, rollback, stream, observe	Build and operate it	Build and operate it	Build and operate it

MUXI is the infrastructure layer. Frameworks help write agent logic. MUXI deploys and operates complete agent systems.

What Ships with MUXI V1

Systems that learn, remember, and act

Formation self-tuning – operational evidence becomes reviewable revisions of MUXI.md, backed by experiments and watched metrics. You decide what gets applied. Docs
Living, auditable memory – layered context plus user/group/formation scopes, immutable events, provenance, rebuilds, selective forgetting, decay, knowledge graphs, Captain's Logs, lessons, and signed on-premises distillation. Docs
Proactive formations – heartbeats, active hours, per-user channels, SOUL.md, notification routing, and built-in slash commands let formations initiate useful work instead of waiting for prompts. Docs
Reasoning RAG – navigate hierarchical document trees, combine tree and vector retrieval, and synchronize remote knowledge from cloud storage, HTTP, rsync, FTP, and SFTP. Docs

Enterprise control without a separate platform

Group-based RBAC – inheritance plus agent, MCP-server, and individual-tool allow/deny rules, with fail-closed external membership resolution. Docs
Multi-tenant isolation – sessions, memory, artifacts, and encrypted credentials stay scoped to the user while one formation serves an entire product or organization. Docs
Persistent artifact memory – generated documents, spreadsheets, presentations, charts, and code are versioned, encrypted, user-scoped, and recallable across sessions. Docs
Production resilience – circuit breakers, fallback models, exponential backoff, graceful degradation, and idempotency keys make retries safe without duplicating work. Docs
Built-in observability – hundreds of typed lifecycle events trace models, tools, memory, workflows, and triggers, with secret and entity-based PII redaction before export. Docs

Agents that connect to everything

MCP in both directions – connect large tool catalogs without injecting every schema into every prompt, and expose any formation as an MCP server to Claude Desktop, Cursor, or another MCP client. Docs
Coding-agent delegation – hand repository work to Claude Code, Droid, OpenCode, Pi, or a custom headless adapter in isolated asynchronous workspaces. Docs
Zero-token job monitoring – deterministic polling tracks long-running MCP work without spending LLM tokens asking whether it finished. Docs
Generative UI – streamed and non-streamed responses can carry typed options, action links, and MCP resources that all twelve SDKs expose idiomatically. Docs
Triggers and outbound routing – schedules, webhooks, and external events activate formations, then transformers deliver results to Slack, Telegram, Discord, email, or custom destinations. Docs

Agent-native execution

Intelligent orchestration – the Overlord routes requests, matches SOPs, decomposes complex work, coordinates agents, and can replan workflows when intermediate results change the best path. Docs
Skills and sandboxed compute – use open SKILL.md packages with progressive disclosure and execute scripts in an isolated RCE sandbox with resource and timeout controls. Docs
Hierarchical model selection – choose cloud, local, or OpenAI-compatible models at the formation, agent, SOP, trigger, skill, or workflow-step level, with aliases and fallback chains. Docs
A2A collaboration – delegate work across formations and external agent services with API-key, OAuth 2.0, HMAC, and OpenID authentication. Docs
Multimodal by default – process images, PDFs, audio, video, Office documents, and structured data through the same formation runtime. Docs

Example Formation

# formation.afs -- define your AI system (it's just YAML)
schema: "1.0.0"
id: "customer-support"
description: Helps customers with product support and refunds

llm:
  models:
    - text: "openai/gpt-4o"
  api_keys:
    openai: "${{ secrets.OPENAI_API_KEY }}"

agents:
  - sales-assistant

# agents/sales-assistant.afs -- define an agent
schema: "1.0.0"
id: sales-assistant
name: Sales Assistant
description: Helps customers with product questions

system_message: Help customers find products and answer questions.

knowledge:
  sources:
    - path: knowledge/product-info.docx
    - path: knowledge/shipping-rates.csv

muxi deploy   # that's it -- running, stateful, API-accessible

📚 Docs: Formation Schema | Examples

Who Is MUXI For?

Platform builders – Building a SaaS with AI features? MUXI handles orchestration, memory, and multi-tenancy so you can focus on your product.
Internal tool builders – Deploying AI systems across an organization? MUXI gives you group-based RBAC, scoped memory, per-user credentials, SOPs, observability, and self-tuning out of the box.
Developers tired of framework hell – Spent months on LangChain orchestration code? MUXI replaces it with YAML configuration and a single deploy command.

Open Source & Self-Hosted

MUXI is open-source and self-hostable. Your data stays on your infrastructure. No vendor lock-in. No per-seat pricing. No usage limits.

Self-hostable – run anywhere, owned by you
Access-controlled – fail-closed group RBAC down to individual tools
Observable – see what's happening, always
Declarative – version-controlled and reproducible
Open – no lock-in, no surprises

Documentation

Looking for...	Go to
Getting started	Quickstart →
SDKs (12 languages)	SDKs →
How MUXI works	ARCHITECTURE.md
Contributing	CONTRIBUTING.md
All repositories	REPOSITORIES.md
Licensing	LICENSE.md
Roadmap	Roadmap →

Agent Skills

This repo includes an Agent Skill that gives any compatible AI agent (Claude Code, Cursor, GitHub Copilot, VS Code, etc.) deep knowledge of the MUXI platform.

See skills/ for setup instructions.

Get Involved

Star this repo to follow progress
Discussions – ask questions, share ideas, get help
Roadmap – see what's coming
@muxi_ai – follow for updates
CONTRIBUTING.md – contribute code

Who's Behind This

MUXI is created by Ran Aroussi, author of Production-Grade Agentic AI (665 pages) and an open-source developer whose tools are used by millions of developers daily.

[!IMPORTANT] MUXI is built on the principles from Production-Grade Agentic AI – a comprehensive guide to building enterprise AI agent systems in production. Download the PDF version here ›.

License

Server and Runtime are ELv2. Everything else (CLI, SDKs, formations, schemas) is Apache 2.0.

TL;DR: Use MUXI freely for your products and business. The only restriction: don't resell MUXI itself as a hosted service. See LICENSE.md for details.

GitHub • Twitter • Discussions

_{For AI/LLM agents: muxi.org/llms.txt}

muxi

Links

README