My desktop AI orchestrator: a chat that routes every request across cloud, free-tier, and local models through a pipeline you draw yourself. The benchmark measures which model deserves each job, the policy decides, and this is the thing that actually does the work.
Work in progressMetis was the counsel inside Zeus's head. The benchmark is her measuring. The orchestrator is what happens when the advisor gets hands.
Every AI tool makes you pick a model and pray. I wanted the opposite: you describe the work, and a router decides which model earns it, task by task, stage by stage. Cheap local models take what they're good at, frontier models get saved for what actually needs them, and free API tiers soak up everything in between.
The core loop is a real build pipeline, not a single prompt. Ask for a website and a planning model writes the plan, a frontend model builds the UI, a functionality model wires the backend, and each one hands its work to the next. The output isn't a wall of text either. It's actual files, written into your actual project folder, verified in an actual browser.
And when the verification fails? It doesn't shrug. Failed checks feed back into a repair stage, the errors and the broken files go to a model whose only job is fixing them, and it rewrites and re-verifies. Up to two passes before it's allowed to admit defeat. Local models get an extra trick on top: because their tokens are free, a local critic auto-checks every stage's output ("is this actually done?") and pushes the model to finish what it started. My local 8B used to give up halfway through writing a stylesheet. Now something notices.
This is the centrepiece. The Orchestration view is a pannable, physics-y canvas where the router sits at the centre and your agents fan out around it: a Planning node running Gemini, a Frontend node on Claude, a Backend node on DeepSeek, whatever you want. Each node carries its model, its temperature, its attached skills, and its fallback chain.
The part I'm proudest of: that graph is not a diagram of the pipeline. It IS the pipeline. When a build runs, the stages come straight from your nodes. Change a node's model and the next build uses it. It stopped being UI the day the pipeline started reading it.
Nodes also carry a Gateway, because a model and the API you reach it through are two different things. DeepSeek's models are reachable through DeepSeek's own API, through NVIDIA's free NIM endpoint, or through OpenRouter. So every node picks its route, sets route fallbacks like it sets model fallbacks, and the runtime falls back across routes before it ever falls back across models.
Which enables my favourite dumb superpower: never running dry. Sign up for a few free tiers (Groq, NVIDIA NIM, Gemini free), give Metis the keys, and when one rate-limits you the router puts it on cooldown and rotates to the next. The chat just quietly says "Groq is rate-limited (cooling 10m), rotated to NVIDIA NIM" and keeps working. Quality routing, cost routing, and quota routing in one policy.
I use Claude Code daily, and the thing I kept stealing from it is the transcript rhythm: say a thing, do a thing, show a slim receipt. So Metis chat works the same way. Prose, then compact expandable action lines: "Edited 3 files, read 2 files, ran 2 checks", click to unfold into individual rows. No dashboards shoved in your face, no walls of paths.
My favourite feature conceptually. Small local models have a creativity problem: ask them to design something and they collapse to the statistical average of the internet, which is a purple gradient and a hero section. They're not uncreative, they're mode-seeking. They can't choose taste, but they're excellent at executing it. So Metis chooses for them, twice over.
First, design seeds: a hand-curated bank of ~40 coherent aesthetics (palette, type pairing, layout archetype, motion personality, copy voice). Every build rolls one, deterministically from the prompt, and injects it as a constraint. A small model given that brief produces something a designer wouldn't wince at, because the choosing was done by the orchestrator.
Second, and better: your own gallery as visual RAG. You drop reference images onto boards, and a local vision model (Gemma, running on my own GPU through Ollama) captions each one into a style card: a description, mood tags, and a palette extracted by median-cut straight from the pixels. When a build runs, the frontend stage retrieves the best-matching card and gets told: replicate this. Your taste, indexed, retrieved, and enforced. No cloud sees your mood board.
This project is the third layer of one long argument:
The benchmark asks "what can this model do?", the policy asks "so who should do this?", and the orchestrator does it. Same name because it's the same wisdom, just increasingly employed. There's also a small community registry on GitHub: skills, presets, and a live model catalog served straight from a repo. Publishing is a pull request, installs are sha256-verified, and my SlopSec security-audit skill was package number one.
The part that still makes me grin: Metis Orchestrator was substantially built by an AI orchestration workflow, which is exactly what it is. I ran a frontier model as the architect: diagnosing bugs, writing specs, reviewing every change, and it dispatched smaller specialist agents to implement each round, with builds verified and committed between rounds. Dozens of features shipped that way in about a week.
It wasn't smooth, and the scars taught me more than the wins. An agent once ran git stash on three days of uncommitted work to "test against a baseline" and I learned about commit discipline the theatrical way. Another pair of agents got stuck delegating to each other in a loop, burning tokens accomplishing nothing, which is a genuinely poetic failure mode for an orchestration project. Every one of those failures became a rule in the specs the next agent received. Orchestrating agents to build an agent orchestrator turns out to be the best possible user research.
Every build request now checks the project folder before deciding anything. Files present means edit mode: load them, change only what's needed. The conversation rides along too, so "now make the header match" knows what came before. This was the week Metis stopped being a prompt container and started being a tool you work in.
Orchestration nodes stopped being decoration: models, gateways, and fallback chains now project straight into the build stages. Also shipped: per-node gateway fallback chains, and side chats that render every API call as a live conversation.
NVIDIA NIM and Groq landed as first-class providers with quota-aware rotation. Rate limits became a routing event instead of an error.
Local Gemma vision captions reference images into style cards; builds retrieve and replicate them. Design seeds shipped alongside, killing the purple-gradient default forever.
Streaming chat with slim action receipts, self-healing builds, mid-run steering, five permission modes, routines with an hour-dial editor, a physics graph view, marketplace + registry, and a contribution heatmap with tokens-kept-local economics.