MŪN

Inspiration

Every AI chatbot has the same problem. You ask one model a question and you get one answer with no way to know if it's making things up. When people face a big decision they get a second opinion. Doctors, lawyers, mechanics, whatever. So why do we just blindly trust whatever a single AI says?

That's the whole idea behind MŪN. Ask them all, see where they agree.

What it does

You ask a question and MŪN sends it to multiple AI models at the same time (Claude, Llama 70B, Llama 8B and more). Then a judge model reads all the answers, figures out where they agree and disagree, and writes one final answer with a confidence rating.

If the models agree, you can trust it more. If they disagree, MŪN tells you that too. Disagreement is useful info that a single chatbot can never give you.

How I built it

The backend is Python with FastAPI. All the model calls fire at once so you only wait as long as the slowest model instead of all of them added up. The wait time is \( \max(t_1, t_2, ..., t_n) \) instead of \( \sum_{i} t_i \):

async def call_models_parallel(model_ids, messages):
    tasks = [call_model(mid, messages) for mid in model_ids]
    return list(await asyncio.gather(*tasks))

Answers stream to the frontend as they're ready. The consensus shows up first, then each model's answer fades in one by one.

The frontend is React. Math renders with KaTeX, and I wrote a normalizer that converts plain text math from the open source models into proper LaTeX. So when a model writes dh/dt = 2/(pi * r^2) in plain text, the user sees:

$$\frac{dh}{dt} = \frac{2}{\pi r^2}$$

Auth and the database run on Supabase, the backend is on Railway, the frontend is on Vercel, and payments go through Lemon Squeezy.

Challenges

The economics almost killed the idea. Each query makes about 4 API calls which costs around \( \$0.03 \) per query. I did the math on my pricing tiers and realized every single tier lost money. That forced me to add usage caps and rethink which queries actually need the full consensus treatment.

Streaming broke in production while working fine locally. FastAPI swallows errors inside async generators so the stream would just close with nothing in it and no logs. I built a little test page that read the raw stream and finally found the bug, then added error events to the stream itself so it can never fail silently again.

Getting three models to sound like one answer was harder than expected. Every model formats things differently. I ended up doing strict formatting rules in the judge prompt plus a cleanup pass on the frontend that strips filler, fixes lists, and converts stray math.

What I learned

• Running models in parallel is what makes this whole thing work. Five opinions cost the same wait time as one.
• Disagreement between models is a feature, not a bug. Telling the user "the models split on this" is more honest than anything a single chatbot can say.
• Do your cost math early. It changed my architecture more than any feature idea did.

What's next

• Moving the routing to OpenRouter so I can offer hundreds of models through one API
• Smart routing so simple questions use one cheap model and hard ones get the full consensus
• A daily crawler that watches for new model releases and adds them automatically

Built With

• auth0
• backboard.ai
• elevenlabs
• mongodb
• openrouter
• react