Open-source, free, and self-hostable

The AI Application Server

You're not building web servers to run websites. You shouldn't build infrastructure to run AI, either.

MUXI runs agent formations – complete AI systems with agents, auditable memory, tools, RBAC, and self-tuning, packaged as deployable units. Define them in YAML, deploy with one command, and connect through APIs, MCP, or 12 native SDKs.

Deploy intelligence, not infrastructure.

Copied!
curl -fsSL https://muxi.org/install | sudo bash
brew install muxi-ai/tap/muxi
powershell -c "irm https://muxi.org/install | iex"

Built for efficiency

Read more →
Time to production
minutes, not months
5 Minutes
Response Time
first token to user
‹100ms
Observability Events
typed & traceable
350
LLM Models
across 21 providers
300+
LLM Cost Saving
semantic caching
50-80%
Test Coverage
on core components
80%+

Agent-Native Infrastructure

MUXI (/ˈmʌk.siː/; Multiplexed eXtensible Intelligence) is infrastructure purpose-built for AI agents. Agents are native primitives – declared in YAML, orchestrated at the infrastructure layer, scaled like containers.

Memory, orchestration, multi-tenancy, and observability are built in. No frameworks to import. No infrastructure to build. Just declare and deploy.

Websites have web servers. APIs have application servers.
AI agents finally have theirs.

Meet the MUXI Stack →

  • Client
    Connect using CLI, API, MCP, or 12 SDKs to manage, monitor, and interact with agents form anywhere.
  • Formation
    Your application, in Agent Formation, a complete AI system defined in YAML and packaged as single deployable unit.
  • Runtime
    Core orchestration: agents, memory, MCP tools, SOPs, task decomposition and execution
  • Server
    Self-hosted infra for production, multi-formation deployments
CLIENT
FORMATION
RUNTIME
SERVER
formation.afs
  1. schema: "1.0.0"
  2. id: "customer-support"
  3. description: |
  4. Helps customers with product support and refunds
  5. agents:
  6. - id: "sales-assistant"
  7. knowledge:
  8. - ./knowledge/product-info.docx
  9. - ./knowledge/shipping-rates.csv
  10. - id: "refund-handler"
  11. knowledge:
  12. - s3://us-east-1.amazonaws.com/acme/policies/*
  13. mcp:
  14. servers:
  15. - id: "shopify"
  16. auth:
  17. type: "bearer"
  18. token: "${{ secrets.SHOPIFY_TOKEN }}"
  19. - name: "stripe"

Declare Once, Deploy Everywhere

MUXI created the Agent Formation Schema – an open spec for declarative AI systems. Agents, knowledge, A2A, and MCP (Model Context Protocol) tools defined in portable .afs files.

Like a Dockerfile for containers, but for agent intelligence.

About Agent Formations →

Deploy like magic

muxi deploy and you're live. Pull formations for version control. Deploy specific versions. Roll back instantly. Hot updates without downtime.

Install the CLI tool →

~/Projects/acme
$ muxi pull @muxi/bookkeeping
$ muxi secrets set OPENAI_API_KEY ••••••••••
$ muxi deploy --profile acme-prod
Validating formation ..... ✓
Creating bundle .......... ✓
Deploying to acme-prod ... ✓
Success 🎉
Formation is live at
https://acme.com/muxi/bookkeeping
+ 7
from muxi import FormationClient
client = FormationClient(
server_url="https://acme.com:7890",
formation_id="my-formation"
)
for event in client.chat_stream({"message": "Hello!"}):
if event.get("type") == "text":
print(event.get("text"), end="")
import { FormationClient } from "@muxi-ai/muxi-typescript";
const client = new FormationClient({
serverUrl: "https://acme.com:7890",
formationId: "my-formation",
});
for await (const event of client.chatStream({ message: "Hello!" })) {
if (event.type === "text") {
process.stdout.write(event.text);
}
}
import fmt
import muxi "github.com/muxi-ai/muxi-go"
client := muxi.NewFormationClient(&muxi.FormationConfig{
ServerURL: "https://acme.com:7890",
FormationID: "my-formation",
})
stream, _ := client.ChatStream(ctx, &muxi.ChatRequest{Message: "Hello!"})
for chunk := range stream {
if chunk.Type == "text" {
fmt.Print(chunk.Text)
}
}
import Muxi
let client = FormationClient(
ServerURL: "https://acme.com:7890",
FormationID: "my-formation",
)
for try await event in client.chatStream(message: "Hello!") {
if event.type == "text" {
print(event.text ?? "", terminator: "")
}
}
using Muxi;
var client = new FormationClient(
serverUrl: "https://acme.com:7890",
formationId: "my-formation",
);
await foreach (var chunk in client.ChatStreamAsync(new ChatRequest { Message = "Hello!" }))
{
if (chunk.Type == "text") Console.Write(chunk.Text);
}

Build with your stack

Native SDKs for every language you already use. No wrappers. No adapters. Idiomatic libraries built from the ground up for Python, TypeScript, Go, Rust, Java, C#, Ruby, PHP, Swift, Kotlin, C/C++, and Dart.

Explore the SDKs →

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 assistants for your team? MUXI gives you group-based RBAC, observability, SOPs, and self-tuning out of the box.

Developers Tired of Frameworks

Spent months on orchestration LangChain code? Replace it with YAML configuration and a single deploy command.

Deploy your first agent in minutes

One minute to install. Five minutes to your first production agent.
No frameworks, no dependencies, no complexity.

View script
Copied!
curl -fsSL https://muxi.org/install | sudo bash
brew install muxi-ai/tap/muxi
powershell -c "irm https://muxi.org/install | iex"


Then, simply follow the quickstart guide to run your first agent formation in under 5 minutes 🚀

Infrastructure, purpose-built for agents

Formations that learn, remember, act, and improve – without giving up control.

LLM-Agnostic

Use major cloud providers, local Ollama/llama.cpp models, or any OpenAI-compatible endpoint through OneLLM.

Select models at the formation, agent, SOP, trigger, skill, or workflow-step level with aliases and fallback chains.

Learn more

Intelligent Task Decomposition

MUXI's orchestrator automatically breaks down complex requests into executable subtasks. No predefined workflows – agents analyze complexity, identify dependencies, and create execution plans on the fly.

Assess task requirements in real-time. Execute in optimal order with parallel processing when possible.

Learn more

Agent Skills & Sandboxing

Package instructions, references, and scripts using the open SKILL.md specification with progressive disclosure.

Execute skill scripts and the bundled compute skill in an isolated RCE sandbox with resource and timeout controls.

Learn more

Multi-Tenant RBAC

Isolate sessions, memory, and credentials per user while sharing one formation across your product.

Group-based RBAC with inheritance and agent, MCP, and tool allow/deny rules keeps every request inside its permitted surface.

Learn more

Agent Collaboration (A2A)

Delegate work across formations and external A2A services with capability-aware routing.

Secure inbound and outbound traffic with API keys, OAuth 2.0, HMAC, and OpenID authentication.

Learn more

MCP Without the Bloat

Connect large tool catalogs without injecting every schema into every prompt.

MUXI indexes definitions once, selects relevant tools at runtime, and filters the surface with layered allow/deny rules.

Learn more

Per-User MCP Credentials

Store OAuth tokens and API keys per user with encryption at rest and automatic credential resolution.

One formation can access the same MCP tools on behalf of many users without crossing credential boundaries.

Learn more

Your Formation Is an MCP Server

Connect any formation directly to Claude Desktop, Cursor, or another MCP client – no adapter code required.

The same agents, memory, tools, and authentication become a secure, AI-native tool surface.

Learn more

Living, Auditable Memory

Every memory write carries provenance in an immutable event stream, making memory explainable and rebuildable.

User, group, and formation scopes add selective forgetting, decay, contradiction handling, knowledge graphs, and Captain's Logs.

Learn more

Local-First Embeddings

Embeddings run locally by default – no data leaves your infrastructure. FAISS-backed vector search powers memory, knowledge retrieval, and semantic routing.

Zero per-request embedding costs. Swap models without changing agent code. Your data stays yours, and your bill stays predictable.

Learn more

RAG That Reasons

Navigate hierarchical document trees instead of retrieving disconnected chunks, so agents can reason across large sources.

Combine vector, tree, and hybrid retrieval with synchronized HTTP, cloud-storage, rsync, FTP, and SFTP knowledge.

Learn more

Multimodal Out-of-the-Box

Handle images, PDFs, audio, and video natively. Vision models (GPT, Claude, Gemini) process screenshots, diagrams, and photos. Extract text from documents. Analyze charts and graphs.

OCR, image classification, and visual reasoning out of the box. Multimodal context flows through entire agent system.

Learn more

Persistent Artifact Memory

Generate documents, spreadsheets, presentations, charts, code, and other downloadable outputs.

Every artifact is versioned, encrypted, user-scoped, and recallable in later conversations.

Learn more

Generative UI

Let formations return typed options, actions, links, and MCP resources that applications render as interactive interfaces.

All 12 SDKs surface widgets idiomatically, while response text provides a universal fallback.

Learn more

Natural Language Scheduling

“Check email every hour” or “remind me tomorrow at 2pm” – agents understand natural time expressions. Recurring and one-time tasks with intelligent datetime parsing and timezone awareness. No cron jobs required.

Schedule once, runs everywhere.

Learn more

Triggers & Outbound Routing

Activate agents from schedules, webhooks, and external events through secure formation endpoints.

Transform results for Slack, Telegram, Discord, email, or custom webhooks with templates, authentication, retries, and fallbacks.

Learn more

Adaptive Workflows

Combine SOP-guided execution with dynamic task decomposition, dependencies, and parallel steps.

Select models per workflow step and optionally replan when intermediate results change the best path forward.

Learn more

Coding-Agent Delegation

Delegate coding tasks to Claude Code, Droid, OpenCode, Pi, or a custom headless adapter.

Jobs run asynchronously in isolated workspaces, while deterministic monitoring tracks long-running work without spending tokens on polling.

Learn more

Proactive Formations

Let formations initiate contact through per-user notification channels instead of waiting for a prompt.

Heartbeats, active hours, soul documents, channel transformers, and built-in slash commands keep outreach useful and controlled.

Learn more

Private Memory Distillation

Distill enterprise knowledge on-premises, then push only pre-processed memory through a signed ingestion channel.

Ed25519 authentication, scoped registrations, trust levels, revocation, and quotas keep every submission controlled.

Learn more

Formation Self-Tuning

Formations analyze operational evidence, detect patterns, and distill what they learn into candidate revisions of MUXI.md.

Review experiments and watched metrics, then inspect, apply, or dismiss every suggested behavioral change.

Learn more

Standard Operating Procedures

Define organizational knowledge that agents reason over, not rigid workflows they follow. Agents interpret procedures contextually and adapt them to specific situations. Version-control your organizational procedures.

Agents understand why procedures exist, not just what they say.

Learn more

SDKs That Feel Native

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

Chat, stream, manage formations, parse UI widgets, and handle typed responses using conventions native to each language.

Learn more

Built-in Observability

Trace model calls, tool use, memory, workflows, triggers, and lifecycle decisions through hundreds of typed events.

Regex and entity-based PII redaction runs before events reach pluggable monitoring and logging exporters.

Learn more

Enterprise Resilience

Circuit breakers, exponential backoff, fallback models, and graceful degradation contain upstream failures.

Idempotency keys make chat, trigger execution, and scheduled-job creation safe to retry without duplicate work.

Learn more

GitOps Workflow

Review version-controlled formations through pull requests, validate them in CI, and promote drafts to production.

Updates and rollbacks preserve persistent memory plus MUXI.md and PENDING-MUXI.md self-tuning state.

Learn more

One Command Deployment

muxi deploy validates, bundles, uploads, and starts your formation through the MUXI Server.

Develop against draft runtimes, update live formations, and roll back to the previous server-managed version.

Learn more

Self-Hosted Control

Run the Go server as a binary or container on your own Linux, macOS, or Windows infrastructure.

Formation runtimes stay isolated through Apptainer/SIF on Linux and the Docker-based runtime runner on macOS and Windows.

Learn more

Open-Source First

Licensed under Elastic License 2.0 and Apache 2.0, with complete source on GitHub. Fork, modify, and use commercially without paying any licensing fees – no vendor permission required. Community-driven roadmap with transparent development.

No black boxes, no proprietary lock-in.

Learn more

Stable V1 Contracts

MUXI V1 coordinates stable contracts across the Server, Runtime, CLI, Formation API, and Server API.

All 12 SDKs share the same 1.x generation for consistent authentication, streaming, errors, idempotency, and UI widgets.

Learn more

Open Source, Sustainably Built

MUXI follows the standard open-source infrastructure model: the core stack is always free and self-hostable. Revenue comes from optional support services – not from paywalls, feature restrictions, or bait-and-switch licensing.

You can self-host for free, forever.

Revenue will come from providing priority support and professional services for production deployments.

Frequently Asked Questions

Everything you need to know about MUXI – who built it, how it works, and where it's going.

If you still have questions, we're here to help.

Who's behind MUXI?

MUXI was created by Ran Aroussi, a developer with over three decades of experience building production infrastructure. His open-source projects receive 20M+ monthly downloads, and he's the author of Production-Grade Agentic AI.

MUXI exists because agents deserve real infrastructure, not framework spaghetti. The roadmap is public, and decisions prioritize long-term stability over short-term growth. No VCs, no exit timeline, and no bait-and-switch licensing – just infrastructure developers can rely on.

What's the licensing model? Can I use this commercially?

MUXI Server and Runtime are licensed under Elastic License 2.0 (ELv2). Formations, CLI, and SDKs are Apache 2.0 (fully permissive).

What you CAN do:

  • Use freely for internal projects, products, and research
  • Use freely for building platforms and commercial applications
  • Build and sell products that use MUXI
  • Deploy for clients and customers
  • Self-host on your infrastructure

What you CAN'T do:

  • Offer MUXI itself as a hosted service

Bottom line: If you're building AI agents for your product or business, you're good to go. The restriction only applies if you're trying to resell MUXI-as-a-Service.

For more details, see our licensing documentation.

What LLM providers are supported?

All major providers via OneLLM (MUXI's provider-agnostic LLM interface), with support for 21 providers and 300+ models (including local models via Ollama and llama.cpp).

Use different providers for different agents, automatic failover between providers, cost-optimized routing. Provider-agnostic by design – never locked into one vendor.

What if you disappear tomorrow?

You'd be fine. Here's why:

No vendor lock-in:

  • Self-hosted on your infrastructure
  • Open-source code you can fork and maintain
  • Formations are portable YAML (not a proprietary format)
  • Standard protocols (MCP, A2A) work with other systems

Sustainable model:

  • Revenue from support/services (not VC burn rate)
  • Maintained by VarOps LLC, a subsidiary of Automaze Ltd - acompany with a long-term commitment
  • No pressure to pivot or shut down
  • Infrastructure projects have decades-long lifespans

This is infrastructure, not a startup product. Built to outlast trends.

How is this different from LangChain/CrewAI?

MUXI makes frameworks obsolete for 90% of use cases. MUXI is infrastructure, not a framework.

MUXI Frameworks
What it is Server that runs agents Python library you import
Deployment muxi deploy → live Write deployment code yourself
Configuration Declarative YAML Imperative Python/TypeScript
Multi-tenancy Built-in per-user isolation Build it yourself
Observability Production monitoring included Add Langsmith/etc.
Async/Scheduling  Native support Build with Celery/etc.

Build and run agents entirely in MUXI – no other frameworks needed. You can optionally use LangChain or CrewAI inside MUXI formations, but it's not required.

Think: Flask is a framework. Nginx is infrastructure. You don't import Nginx – you deploy to it. MUXI is the nginx.

Do I need the Server?

You can use either the Server, the Runtime, or both:

Runtime only (embedded):

  • Import as Python library
  • Embed in your existing application
  • Full programmatic control
  • Good for: Custom integrations, research, single-tenant apps

Server (recommended for most):

  • Deploy formations with MUXI push
  • Multi-tenant isolation built in
  • Hot deployments, automatic restarts
  • API/CLI/SDK management
  • Good for: Production deployments, SaaS products, teams

Most developers will want the Server. The Runtime is there if you need lower-level control.

What's your roadmap?

You can see the full roadmap and vote for features on the Roadmap GitHub Project.

Can I contribute?

Yes! MUXI is open source and community-driven.

Ways to contribute:

  • Code contributions (Runtime, Server, SDKs)
  • Documentation improvements
  • Formation examples and templates
  • Bug reports and feature requests
  • Community support (discussions, Discord)

See our contributing guide to get started.

We're building infrastructure for everyone – your input shapes the future.

Why “MUXI”?

MUXI = Multiplexed, eXtensible Intelligence

The name reflects the core architecture: multiplexing multiple specialized agents into cohesive intelligent systems, with extensibility at every layer.

Where can I get help?

Community support:

Need production help? Professional deployment services coming soon. Contact us if you're interested in expert assistance when it launches.

What about enterprise support?

We're planning professional support services for teams that need deployment assistance, custom integrations, or SLA-backed help. This is coming in the next few months.

Current options:

  • Self-hosted: Always free
  • Community support: GitHub Discussions (free)

Coming soon:

  • Priority support via dedicated Slack channel
  • Professional deployment services
  • Custom integrations
  • SLA-backed support

See the support page for information on professional services.