Can Multi-Model Discussion Actually Solve AI Hallucination? A Reflection from an MVP Practitioner

I'm a beginner currently transitioning into tech, and I've been building an MVP of a multi-expert AI system.

The current core mechanism is:

1.User asks a question

2.System calls multiple expert models in parallel (medical, law, strategy, general)

3.Each model responds independently

4.A director brain aggregates the output

5.Supports random multi-brain self-interaction mode

6.A simple memory module

After the user asks a question, multiple expert models respond in parallel, and the outputs are aggregated. More perspectives should be more reliable than a single one — that logic sounded reasonable.

But after running it for a while, something started to feel off.

I began to wonder: does this actually achieve what I was hoping for — multi-brain cross-validation that improves information accuracy? Can this kind of AI really be trusted?

If each individual model is itself unreliable, then what does their "consensus" actually represent? Is it converging toward correctness, or just making unreliability look more convincing?

1. The core problem: the validator itself is unreliable

What I'm doing, in essence, is calling multiple off-the-shelf models and having them answer the same question concurrently. Accuracy and certainty still depend on each model's own knowledge base — and AI models aren't entirely trustworthy. They make things up. They hallucinate with confidence.

It doesn't eliminate uncertainty. It just spreads the source of uncertainty from one model to multiple models.

My original intent was to build "cross-validation" — multiple brains questioning and testing each other, eventually converging on more reliable conclusions. But what I've built so far feels more like "multiple models talking past each other, then stitched together."

This isn't true cross-validation. It's simulating the appearance of discussion.

1. The difference between known and unknown problems

When we test these systems, we almost always use questions we already know the answers to.

But those questions are already in the training data. We're not testing reasoning ability — we're testing memory. True "reliability" should be demonstrated when facing unknown problems. And on unknown problems, we have no reference to verify whether the model's answer is correct.

If the validator itself is unreliable, what does the validation result even mean?

1. The design direction is right, but the foundation is wrong

The idea of "multi-brain cross-validation" itself is sound — it's a reasonable response to the problem of "AI being unreliable." The issue lies in its precondition: the participating models themselves need to have a baseline level of reliability. If the models themselves are unreliable, then no amount of discussion will move things in the right direction.

So my MVP isn't meaningless — it got me to the point where I can see this problem clearly. But it also means that if I want this direction to truly work, I need to think about not just "how models discuss," but "how models become more reliable."

1. A new possibility: should validation happen inside the model itself?

Recently I've started thinking about a question:

Should multi-brain cross-validation happen inside the model itself?

If this direction could work, it might mean: models would no longer need such massive amounts of training data. This could be a fundamental solution to reducing data dependency, and potentially another form of AI self-learning.

This is different from another "AI self-learning" path I've been considering, but I see them as parallel possibilities.

1. Choices at the current stage

If I want this MVP to have real differentiating value, I need to think about several things:

Actually solving AI reliability — not just simulating it

Structural design is the path, but it only has value if it actually solves a real problem

To be different, the model itself needs to be different — otherwise validation itself can't be validated

The direction is right, but the foundation is wrong. This leads to:

Should I build my own wheels?

Or use existing wheels to build the framework first?

What are the risks and returns of each choice?

Would this become over-engineering? After all, it's just an MVP

But an MVP still needs to prove something

1. Current status

I don't have an answer yet.

Should I pivot? Should I continue in the current direction? I'm still evaluating. At this stage, I lack the ability to test these ideas, but at least I can now see where the problem lies.

This article is a record of my current thinking, not a conclusion. I'll update it as I continue experimenting.

If you're also working on similar multi-agent systems, or have your own views on this direction, feel free to share in the comments.

Links:

GitHub: