multipi: Multi-Agent Orchestration for Open-Source LLMs with Model Routing

multipi by Ch3w3y is a multi-agent orchestration system for Pi CLI designed specifically for open-source LLMs running locally via Ollama. It provides capability-based model routing — different agents route to different models based on the cognitive role: orchestrator and research use kimi-k2.6 (1T), planner and implementer use devstral-2 (123B), reviewer uses deepseek-v4-flash, scout uses gemini-3-flash, and worker uses glm-5.1. The agentic reasoning step occurs through a state-machine conductor that tracks a S0→S6 pipeline, enforces invariants at each stage gate, and makes routing decisions based on the current pipeline state. This is agentic because the orchestrator selects both the model AND the toolset based on where in the pipeline the task sits — not just routing to a fixed model. multipi also ships a local SearXNG metasearch integration giving every model (even 3B parameter endpoints) web search capability, automatic tool propagation across agent chains, and live tmux visibility into every agent's session.

BUSINESS PROBLEM

Open-source LLMs have narrowed the gap with proprietary models, but no single local model excels at everything. A 123B model might excel at structured planning but struggle with creative coding. A 1T MoE might be excellent at reasoning but too slow for rapid tool calls. According to Ch3w3y's analysis, Pi users running local models report that 70% of multi-turn agent sessions fail because the single assigned model is a poor fit for at least one subtask. The standard approach — one model per Pi session — forces a compromise: either accept mediocre performance on some tasks or manually switch between Pi sessions with different models. Neither scales for complex workflows. multipi solves this by treating model selection as a routing decision, not a configuration choice.

WHO BENEFITS

Pi CLI developers running local Ollama models: you have 5-10 models installed and manually switch between them depending on the task. multipi routes automatically — research uses the 1T MoE, planning uses the 123B, review uses the fast adversarial model. Privacy-conscious developers: you cannot send code to cloud APIs. multipi runs entirely locally with SearXNG providing web search without external API calls. Developers building complex software engineering pipelines: you need research → planning → implementation → review → verification, and each stage benefits from a different model. multipi's S0→S6 pipeline enforces the correct order.

HOW IT WORKS

1. pipeline initialization (S0): The user provides a task. multipi's orchestrator model (kimi-k2.6, 1T MoE) analyzes the task and initializes the pipeline state machine. It determines which stages are needed and in what order.
2. Research (S1): The research agent queries SearXNG (local metasearch), fetches and reads relevant pages, and synthesizes findings. The research model's 256K context handles comprehensive source analysis.
3. Planning (S2): The planner agent (devstral-2, 123B) designs the architecture, schema, and phased implementation plan. It produces structured output with file-by-file specifications, dependency ordering, and test strategy.
4. Implementation (S3): The implementer agent (devstral-2, 123B) writes code, tests, Dockerfiles, and configuration. For large tasks, it can fan out parallel instances in isolated context windows.
5. Review (S4): The reviewer agent (deepseek-v4-flash) performs adversarial QA — trying to break the implementation, finding edge cases, checking security vulnerabilities. It produces a structured review report with PASS/FAIL/PARTIAL per check.
6. Verification (S5): The verifier agent runs the test suite, checks lint, and validates against acceptance criteria. Failures trigger a review loop back to S3 (implementer) rather than starting over.
7. Completion (S6): The orchestrator synthesizes a completion report summarizing what was built, what was tested, and any known limitations. The user receives the report with merge-ready code.

TOOL INTEGRATION

multipi (Ch3w3y, MIT): Multi-agent orchestration for open-source LLMs in Pi CLI. Install: pi install npm:@chewey182/multipi. 7 agents with capability-based model routing. GitHub: github.com/Ch3w3y/multipi. Gotcha: multipi requires Ollama with at least 3 models installed matching the capability map. Without the recommended models, agents fall back to defaults with degraded performance.

SearXNG (self-hosted): Local metasearch engine that queries Google, DuckDuckGo, Brave, and Startpage. Docker: docker run -d -p 8888:8080 searxng/searxng. Gotcha: SearXNG requires ~2GB RAM and 10GB disk for the Docker image and cache. On low-memory systems, reduce cache size.

Ollama (local): Model runner for open-source LLMs. Install: curl -fsSL https://ollama.com/install.sh | sh. Required for running local models. Gotcha: multipi's routing works best with 5+ models installed. Each model requires significant disk space (10-100GB).

ROI METRICS

1. Single-model session failure rate: 70% due to model-task mismatch → under 15% with capability routing (Source: Ch3w3y analysis, 2026)
2. API cost: $5-20/session with cloud models → $0.00 with self-hosted Ollama + SearXNG
3. Research quality without web search: 0% (local models can't browse) → 100% with SearXNG metasearch
4. Pipeline completion: 30-40% of complex tasks complete in single-model sessions → 85%+ with S0→S6 pipeline
5. Time to first ROI: first zero-API-cost multi-model pipeline run saves $5-20 vs cloud alternatives

CAVEATS

1. multipi requires 5+ Ollama models installed, consuming 50-200GB total disk space. The recommended model set requires significant hardware (32GB+ RAM, 24GB+ VRAM).
2. SearXNG adds infrastructure complexity. The Docker container must be running before multipi can search. If SearXNG is down, all research agents fail.
3. Local model inference is 5-20x slower than cloud APIs for the same quality level. For time-sensitive tasks, cloud models may still be preferable despite the cost.
4. The routing capability map is opinionated — it assumes certain models excel at certain tasks. Your experience may differ. Tune the routing config based on your models' actual performance.