When you hit something complex, contested, or expensive to get wrong, your agent runs a panel of 2–3 models over your private context — and gets back where they agree, where they break, and why. Your agent does the synthesis; you get the audit trail when it matters. The disagreement is the deliverable, not a step on the way to one answer.
A compound model that collapses a panel into one answer is genuinely good — for the work where there's a right answer to find. mumo is for the other kind: the call that's contested, expensive to get wrong, and specific to your situation.
Code, lookups, well-trodden tasks with an answer that isn't in dispute. A single frontier model is faster and cheaper.
Wide public retrieval where coverage is the bottleneck and a best answer exists to converge on. The intern's executive summary.
Judgment calls over your own codebase, docs, and history — where the reasons models disagree matter more than the average. The war room.
Inside the workflow you already have — your agent reaches for the panel, and you stay in the loop.
Mid-task, on a call it shouldn't make alone, your agent invokes mumo over MCP — and brings your private context with it: the repo, the issue history, the design doc, your memories. The panel argues over your actual situation, not a generic one.
No assigned roles, no model seeing another's answer first. Each writes its own raw position — so what surfaces is genuine independent reasoning, not a chorus shaped by whoever spoke first.
Now the deliberation: each model sees the others' positions and reacts to specific claims— championing, challenging, building on, or reframing them. Not parallel monologues — models engaging each other's strongest points.
Back comes the full raw responses plus the claim map — a structured artifact that pulls every quote that drew a reaction and tags it by how each model responded: Keep, Challenge, Explore, Core, Shift. One glance shows where they converge and exactly where they split.
Stop if you have what you need. Or append another round that automatically carries full context for every participant — feed in snippets and your own prose to steer. mumo never decides for you; the call stays with the party who knows your situation.
Every round is reviewable on a permanent page: the raw prose and the claim map, every claim traceable to the model that made it. Reasoning provenance — how the call was argued, on the record.
Five typed reactions turn a pile of opinions into something you can navigate — you see not just that the models disagreed, but how.
This holds up — endorse it and carry it forward.
Push back, usually with a concrete alternative.
An open thread worth pursuing before you decide.
The load-bearing point the rest hinges on.
Reframes the question or moves the angle.
Every multi-model tool needs something to make sense of the panel. The question is who — a stranger who parachutes in once, or the agent that lives in your work.
A generic model that reads the panel once, writes the answer, and is gone.
The agent already in your harness — holding your context, your history, and the thread of how you decide.
A synthesizer's single answer is a strong, fast tool — until the call is contested. Collapsing a panel into one answer can quietly bury the objection that should have changed your mind, and you can't see what it dropped. mumo takes the other fork: a structured, attributed map of where the models agreed, split, and why — the disagreement kept intact, not smoothed away. The answer still comes, just downstream — from the party grounded in your situation: you, or your agent.
Panel in, judge compares, one model writes the answer.
The same panel, but the disagreement is the deliverable you work with.
mumo doesn't pretend to know what you did next, and it won't try to be your tracker. It keeps something narrower and truer: how the call was actually argued — which claims held up, what your context contributed, where the panel converged and where it didn't — reviewable whenever the decision comes back around.