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 packaged as deployable units. Define agents, memory, tools, and orchestration in YAML. Deploy with muxi deploy. Build your product on top via APIs and SDKs.

Deploy intelligence, not infrastructure.

From zero to a multi-agent AI system
< 5 min Watch now →

Built for efficiency

Read more →
Time to production
minutes, not months
5 Minutes
Response Time
first token to user
‹100ms
Observability Events
typed & traceable
349
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 →

  • SDKs
    Python, TypeScript, Go, Swift, Java, and more – manage, monitor, and interact with agents programmatically.
  • 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
SDKs
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 observability and enterprise-grade features like SOPs 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

Production-grade features, out of the box. No assembly required.

LLM-Agnostic

Use OpenAI, Anthropic, Google, Azure, AWS Bedrock, local Ollama/llama.cpp, or any OpenAI-compatible endpoint. Swap providers in seconds and mix models per agent – GPT-5 for reasoning, Claude Sonnet for writing, local Llama for high-volume tasks.

Automatic failover when providers fail. Never locked into one vendor's pricing or roadmap.

Learn more

Multi-Tenant by Design

Each user stores their own credentials – OAuth tokens, API keys, connection strings. Agents access tools on their behalf with complete session isolation. User A's conversation history never leaks to User B. One formation, personalized for everyone.

Built-in RBAC defines who can deploy, chat, and manage credentials at the formation level.

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 Collaboration (A2A)

Agents within your formation work together seamlessly. Delegate tasks across formations via A2A protocol. Collaborate with external agents from other organizations.

Intelligent task routing based on capabilities and domain knowledge. Build distributed agent systems that work as one.

Learn more

MCP Without the Bloat

Access 1,000+ MCP tools - GitHub, Slack, Stripe, Google Drive, databases, file systems, APIs, and more - with a fraction of the tokens

Unlike typical implementations that dump schemas into every context window, MUXI loads definitions once and indexes them. Subagents pull only what they need at runtime.

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

Artifact Generation

Agents generate downloadable artifacts on demand – documents, spreadsheets, presentations, code files, reports, and visualizations. Users get tangible deliverables, not just conversation responses.

Create formatted outputs that integrate directly into workflows.

Learn more

Real-Time Streaming

Real-time streaming for responsive user experiences. Agents stream responses as they think, not after completion. WebSocket support for live updates. Server-sent events for long-running workflows.

Token-by-token delivery for chat interfaces. Progress updates for multi-step operations.

Learn more

One Command Deployment

muxi deploy and you're live! Bundle your formation, push to your server, and it's running. Use muxi pull for version control. Deploy specific versions. Hot updates with zero downtime. Roll back instantly.

Like Vercel® for websites – but for AI agents.

Learn more

SDKs That Feel Native

Complete SDKs for Python, TypeScript, Go, Swift, Java, and more. Interact with agents programmatically using languages you already know. Deploy, manage, chat, and stream responses using type-safe clients and full IDE autocomplete.

Build platforms, products, and custom tooling on top of MUXI without weeks of training.

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

Webhook Triggers

External systems trigger agent actions via HTTP endpoints. GitHub pushes, Stripe payments, monitoring alerts – any event can activate agents. Template-based message generation from event data.

Secure, authenticated endpoints created automatically per formation.

Learn more

Dynamic Async Execution

Smart pattern that stays synchronous during human approval, then switches to async after confirmation. Intelligent conplexity detection requires human approval only when needed.

Session tracking and webhook notifications are used for long-running workflows.

Learn more

Event-Driven Architecture

Agents respond to scheduled tasks, webhook events, and user interactions through one unified orchestration layer. Build reactive systems that operate autonomously.

Complete event history for debugging and audit trails, defined in the formation YAML.

Learn more

Multi-User MCP Access

Each user securely stores their own OAuth tokens and API keys. Agents automatically discover and use user credentials for MCP access, encryption at rest.

One formation can serve thousands of users with personalized experiences.

Learn more

Domain Knowledge System

Pre-load agents with knowledge from files and URLs. FAQs, policies, docs, and specs – agents retrieve relevant context via RAG without fine-tuning models. Update knowledge by updating files. Changes available immediately.

Supports markdown, PDFs, text, Office, images, structured data, and more.

Learn more

Three-Tier Memory

Buffer memory for immediate context, persistent storage for long-term retention, vector search for semantic retrieval. Agents remember what matters across sessions. Automatic tiering – MUXI decides what goes where.

Important information promoted to persistent, old content archived automatically.

Learn more

User Synopsis Caching

LLM-synthesized user profiles automatically generate and cache summaries from conversation history. Two-tier caching: identity cached long-term, context refreshed regularly.

Reduces LLM costs by 80%+ while maintaining fresh, relevant context. Caches update as new information emerges.

Learn more

Intelligent Context Management

Automatic FIFO cleanup when memory limits reached. Relevance scoring keeps important information longer. Context prioritization surfaces the most relevant information first in every interaction.

System learns what's important over time. Memory that gets smarter, not just bigger.

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

Adaptive Workflow Creation

Workflows aren't scripted – they're generated. Agents assess situations, determine optimal approaches, and adjust strategies as execution progresses. Same request, different contexts = different workflows.

Plans evolve as agents learn from intermediate results. Non-deterministic by design.

Learn more

Built-in Observability

See everything agents do, in real time. Track decisions, LLM calls, tool usage, and workflows. Stream events 10+ systems, including Datadog, Elastic, Splunk, OpenTelemetry, and more.

No external APM required. No blind spots. No guessing. Observability built into infrastructure.

Learn more

Enterprise Resilience

Circuit breakers stop cascading failures. Exponential backoff with intelligent retry logic. Graceful degradation keeps systems working when components fail.

With ~72% cache hit rate (~92% semantic), MUXI ensures reduced LLM costs and latency.

Learn more

GitOps Workflow

Formations defined in YAML, version-controlled like code. Pull requests for agent changes. Team review of configurations. Test formations before production. Automated testing in CI/CD.

Every deployment tracked with instant rollback to any previous version.

Learn more

Self-Hosted Control

Single binary or Docker-native deployment, with zero runtime dependencies – runs anywhere. On-premises for compliance, cloud for scale, air-gapped for maximum security. Your infrastructure, your data, your models.

Complete data sovereignty with no vendor access to your information.

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

Production-Ready Day One

88.9% test coverage across 63,000+ lines of test code. Zero downtime deployments. Battle-tested reliability patterns built in, not bolted on as an afterthought.

Enterprise support available with SLA-backed response times, priority bug fixes, and architecture consulting.

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 (hopefully) come from GitHub Sponsors supporting OSS development, and from providing priority support andprofessional 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.