Orchestrator Index
aka Orchid
A SOLID, YAML-driven multi-agent framework built on LangGraph.
New · Typed data pipelines →Everything a production agent needs
Nine built-in capabilities, configured from YAML — each documented, pluggable, and independently swappable.
YAML-first
Define agents, skills, tools, and prompts entirely in agents.yaml — no code required for most use cases.
Multi-LLM
OpenAI, Anthropic, Google Gemini, Groq, Ollama — switch providers by changing a single YAML field.
Decision Models
Route internal judgements — routing, guardrails, tool choice, model selection — to a dedicated decision LLM with deterministic fallbacks.
Customizable Agents
Full control over agentic behaviour, tools, skills, and mini-agents. Compose specialised agents via YAML or Python.
Event-Driven
Pollen and Bloom enable reactive, event-driven agent workflows — react to signals, not just prompts.
Mini-Agents
Fork focused sub-agents for a single turn: parallel agentic loops with curated tool subsets, synthesised back into one answer.
Hierarchical RAG
Five-level scoped retrieval (root→tenant→user→chat→agent) with pluggable query strategies and Qdrant / ChromaDB built-in.
MCP-native
Connect any MCP server. Supports none, passthrough, and OAuth auth modes out of the box.
Durable & Resumable
Every thread is checkpointed. Crash, pause, or hand off — resume mid-conversation from SQLite, PostgreSQL, or your own backend.
New · Typed DAGs
Data pipelines
Combine deterministic code, LLM jobs, agents, decisions, maps and sub-pipelines over a validated information graph. Run them from Python, HTTP, the CLI, an agent tool or a Pollen/Bloom trigger.
Model-agnostic
Any model. Any provider.
One YAML field.
Orchid never locks you into a vendor. Every agent takes a LiteLLM-style model string — switch from OpenAI to Anthropic to a fully local Ollama setup by editing a single line, and mix providers across agents in the same fleet.
- Fleet defaults, per-agent overrides — set a fleet-wide model, then pick a different provider for any agent.
- Automatic fallback —
fallback_modelis tried on 503, rate limit or timeout errors. - Cheap judges, smart workers — prose models answer users, decision models judge internal seams on a budget model. Decision Models →
- Local-first — point
ollama_api_baseat your machine and run the whole fleet offline.
version: "1"
defaults:
llm:
model: "gemini/gemini-2.5-flash" # fleet default
fallback_model: "ollama/llama3.2" # on 503 / rate limit / timeout
agents:
support:
llm:
model: "openai/gpt-4o"
temperature: 0.1
analyst:
llm:
model: "anthropic/claude-sonnet-4-5"
local-worker:
# inherits defaults — runs fully on local OllamaIntelligence as a Service
One agentic core.
Three ways to expose it.
Orchestrator Index builds the intelligence layer on top of any LLM. Your agents, tools, and skills are defined once — then exposed as an MCP gateway, a REST API, or embedded directly in Python code.
Prose models answer users. Decision models answer questions.
Thirteen internal seams — routing, guardrails, tool choice, model selection, delegation and more — can be routed to a cheap, dedicated LLM that returns typed judgements with calibrated confidence. Any failure, refusal or low confidence falls back to the exact pre-existing behaviour. Decision Models →
# Route internal judgements to a dedicated decision LLM.
# Opt-in: without this block, every flow behaves as before.
decision_models:
gatekeeper:
protocol: llm
model: gemini/gemini-2.5-flash-lite
decisions:
budget:
max_calls_per_turn: 4
max_total_ms: 4000
points:
retrieval_strategy:
model: gatekeeper
confidence_threshold: 0.8
options:
strategies: [simple, hyde] # fallback: configured strategy
guardrails:
model: gatekeeper
options:
on_failure: closed # fallback: configured guardrails
delegation:
model: gatekeeper # fallback: no delegationThe Ecosystem
Five separable packages with a one-direction dependency graph.
What is Orchestrator Index?
Orchestrator Index is an open-source, YAML-driven multi-agent AI framework built on top of LangGraph. It lets you define autonomous agents, their tools, skills, and behavioural prompts entirely in configuration files — no Python or TypeScript required for the majority of use cases. Change a single YAML field and swap from OpenAI to Anthropic, Google Gemini, Groq, or a local Ollama model without touching a line of code.
At its core sits GenericAgent, a composable agent that delegates to specialised collaborators: a SkillDetector for intent matching, an MCPDispatcher for external tool calls, and a SkillExecutor for step-by-step reasoning. Each agent can be extended with custom Python classes while keeping the framework’s SOLID architecture intact — new behaviour is added by subclassing, never by modifying existing code.
Orchestrator Index ships with a five-level hierarchical RAG system (root → tenant → user → chat → agent) backed by Qdrant or ChromaDB, giving you fine-grained scoping of retrieved context across multi-tenant deployments. Documents are parsed once and indexed automatically, so your agents always have access to the most relevant knowledge without manual pipeline management.
External tool integration is handled through the Model Context Protocol (MCP). Orchestrator Index connects to any MCP server with three authentication modes — none for local development, passthrough for forwarding user tokens, and full OAuth 2.0 discovery for production-grade integrations. Capabilities are cached proactively at session start, so the supervisor never blocks on discovery RPCs during a conversation.
The framework exposes its intelligence layer through three runtimes: a REST API (FastAPI) for web and mobile backends, a command-line interface for quick prototyping, and an MCP gateway that lets any MCP-capable host LLM — Claude, GPT, Gemini, or custom — call your agents as tools. Chat history is persisted via a pluggable storage backend (PostgreSQL or SQLite), and every conversation can be resumed, shared, or summarised on demand.
Whether you are building a customer support bot, a knowledge-base assistant, or a multi-agent research pipeline, Orchestrator Index gives you the configuration-first abstraction layer to move fast without sacrificing extensibility. The entire ecosystem — library, API, CLI, frontend, and MCP gateway — is composable, independently deployable, and designed to grow with your project.
Two files. Four runtimes.
orchid.yml defines runtime settings (LLM, RAG, storage).agents.yaml defines agents, tools, and skills. Together they power the API, CLI, MCP gateway, and Python SDK.
version: "1"
defaults:
llm:
model: "ollama/llama3.2"
temperature: 0.2
agents:
basketball:
description: >
NBA basketball expert with player stats,
team rosters, and head-to-head comparisons.
tools:
- get_player_stats
- compare_players
- get_team_roster
psychologist:
description: >
Sports psychologist for player motivation,
mental toughness, and team dynamics.
tools:
- assess_motivation
- suggest_mental_strategycurl -X POST http://localhost:8000/chats/my-chat/messages \
-H "Content-Type: application/json" \
-d '{"content": "Tell me about LeBron James"}'Run it locally
One command starts the demo with Ollama-powered models.
docker compose -f docker-compose.demo.yml up --build