Orchestrating
Intelligence
Motet is an open-source AI runtime for multi-agent systems. Model-agnostic with intelligent routing, distributed command execution, and multiple reasoning strategies — so you can focus on what your AI does, not how it runs.
from motet import motet
from motet_sdk import MotetContext
@motet.command(timeout_seconds=60)
def analyze(data: AnalysisData, motet: MotetContext):
# Runs distributed across workers — automatically
result = motet.do(research, data=ResearchData(query=data.topic))
return {"analysis": result}
The AI runtime for
production multi-agent systems
Model-agnostic, multi-agent, and distributed — from reasoning to deployment.
Multi-Agent Architecture
Compose agents that delegate to sub-agents, each with their own tools, models, and reasoning strategies. Agents coordinate through distributed commands.
Model Agnostic
Swap between OpenAI, Anthropic, Google, Ollama, or any provider. Canonical protocol types mean your commands work the same regardless of the model behind them.
Intelligent Model Routing
Route requests to the right model based on task complexity, cost, latency, and capability. Model profiles and policies make routing declarative.
Multiple Reasoning Strategies
Choose from Direct, Chain-of-Thought, Tree-of-Thought, ReAct, and more. Automatic selection by task complexity or manual override.
MCP Tool Integration
First-class Model Context Protocol support with auto-discovery, health monitoring, and a lightweight stream proxy architecture.
Shared Multi-Agent Memory
Agents share working, short-term, and long-term memory with hybrid retrieval — keyword, semantic, and temporal. Context persists across conversations and consolidates automatically.
Real problems,
intelligent solutions
Motet gives teams the building blocks to tackle complex, domain-specific AI challenges at scale.
Financial Services
Compliance teams drown in regulatory documents, risk assessments, and audit trails across jurisdictions — manual review is slow and error-prone.
Multi-agent workflows that parse regulatory filings, cross-reference compliance rules, and surface risks automatically. Agents specialize by domain (SEC, GDPR, SOX) and coordinate through distributed commands.
Healthcare & Life Sciences
Clinical data is fragmented across EHRs, research papers, and lab systems. Synthesizing patient insights or trial data requires navigating siloed, unstructured information.
Orchestrate agents that retrieve from multiple data sources, reason over clinical guidelines, and produce structured summaries — with full audit trails and deterministic tool execution.
Legal
Contract review, due diligence, and case research involve hundreds of documents with complex cross-references that take teams of associates weeks to process.
Deploy reasoning strategies (CoT for clause analysis, ReAct for iterative research) across a fleet of workers. Parallel document processing with motet.apply() turns weeks into hours.
E-Commerce & Retail
Product catalog management, dynamic pricing, and personalized recommendations require real-time decisions across millions of SKUs and customer signals.
Model-agnostic routing picks the right model for each task — fast models for real-time pricing, capable models for product description generation. Agents compose catalog, pricing, and recommendation commands.
Software Engineering
Developer tooling struggles to coordinate across codebases, CI systems, documentation, and issue trackers — each requiring different context and capabilities.
MCP tool integration connects to GitHub, databases, and dev tools natively. Multi-agent architectures delegate code analysis, test generation, and documentation to specialized sub-agents.
Customer Operations
Support teams handle repetitive inquiries across channels while complex issues require escalation, context switching, and knowledge base lookups that slow resolution.
Tiered agent systems handle routine queries directly and escalate complex cases to specialized agents with full conversation memory. Workflow orchestration manages handoffs and follow-ups automatically.
Three steps to distributed AI
Go from a single function to a scalable, distributed system.
Define commands
Write Python functions decorated with @motet.command. Each command is a self-contained unit of work with typed inputs and outputs.
@motet.command(timeout_seconds=30)
def summarize(data: SummarizeData, motet: MotetContext):
result = motet.do(model_inference, data=ModelInferenceData(...))
return {"summary": result["text"]}Compose & orchestrate
Chain commands together with motet.do(), run them in parallel with motet.join(), or fire-and-forget with motet.dispatch().
reviews, pricing = motet.join([
(scrape_reviews, ProductData(id=product_id)),
(scrape_pricing, ProductData(id=product_id)),
])Deploy & scale
Deploy with Docker Compose. Workers auto-discover capabilities, route commands intelligently, and scale horizontally.
$ docker-compose -f docker-compose.distributed.yml up -d --scale worker=8
Ready to build?
Motet is in private beta. Request access and we'll get you set up with onboarding and support.