We spend a lot of time asking one question:
Which AI model is the smartest?
GPT? Claude? DeepSeek? MiniMax?
But after experimenting with Hermes Agent’s Mixture of Agents (MoA), I started wondering whether that’s the wrong question.
What if, instead of choosing one AI model, you could make several models analyze the same problem and let another model combine their best ideas?
In other words:
3 AI Models → 1 Smarter Decision → Better Results
That’s the idea behind Mixture of Agents.
And I decided to put it to the test.
🤝 What Is Mixture of Agents?
Most AI agents work with a single model.
You send a prompt.
The model reasons about it, uses tools, and gives you an answer.
Mixture of Agents introduces another layer.
Your prompt is first sent to multiple reference models in parallel.
Each model independently analyzes the same problem and provides its perspective.
Their responses are then given to an aggregator model, which reviews the different approaches, combines the strongest ideas, and decides what to do next.
The reference models act like advisors.
The aggregator is the decision-maker.
Only the aggregator can:
- 📂 Read files
- 🛠️ Execute tools
- 💻 Run terminal commands
- ✍️ Modify code
- ✅ Produce the final response
So from your perspective, you’re still working with one AI agent.
Behind the scenes, however, that agent is consulting multiple AI models before making important decisions.
🏢 Think of It Like Asking Multiple Senior Engineers
Imagine you’re making an important architecture decision.
Would you rather ask one senior engineer?
Or have three senior engineers independently review the problem first?
One might immediately spot a security issue.
Another might question whether the architecture will scale.
The third might find a much simpler implementation.
None of them necessarily has the complete answer.
But a decision-maker who can see all three perspectives has more information before choosing a direction.
LLMs work in a similar way.
Different models have different strengths, weaknesses, biases, and reasoning patterns.
The goal of Mixture of Agents isn’t simply to add more models.
It’s to give the final model access to diverse perspectives before it commits to a solution.
🎥 Full video walkthrough
⚙️ How the Architecture Works
The basic workflow looks like this:
YOUR PROMPT
│
┌────────────┼────────────┐
▼ ▼ ▼
AI Model AI Model AI Model
Advisor Advisor Advisor
│ │ │
└────────────┼────────────┘
▼
Aggregator Model
│
Makes Decision
│
▼
Tool Calls + Final Answer
The important distinction is this:
Reference models advise. The aggregator acts.
The advisors don’t modify your project or execute tools.
They analyze the problem independently and provide additional perspectives that the aggregator can use when deciding what to do.
🧪 Putting 3 AI Models to Work
For my experiment, I configured:
- ⚡ DeepSeek V4 Flash — Reference Model
- 🚀 MiniMax M2.7 — Reference Model
- 🧠 GPT-5.4 — Aggregator Model
I then gave the agent a practical task:
Build a Kanban board for a solo YouTube creator.
When I submitted the prompt using /moa, Hermes sent the same problem to both reference models in parallel.
Each analyzed the task independently.
Once their responses were ready, the aggregator received:
My original prompt + DeepSeek’s perspective + MiniMax’s perspective
It could then synthesize those ideas and decide how to approach the actual implementation.
The result?
After roughly 14 minutes, the agent had built a functional single-page Kanban application with:
- 📋 Seven creator-focused workflow columns
- 📝 Editable task cards
- 🏷️ Tags and priorities
- 📅 Due dates
- ☑️ Checklists
- 🔍 Search
- 🎛️ Filtering
- 🖱️ Drag-and-drop cards
- 📊 Workflow statistics
- 💾 Local browser persistence
All from a single initial prompt.
The interesting part wasn’t just the finished application.
It was being able to see how multiple models contributed perspectives before the acting model committed to an approach.
👀 Watching Different AI Models Approach the Same Problem
One of the most interesting parts of Hermes Agent’s implementation is the visibility into what the reference models are doing.
While the task is running, you can see each reference model independently analyzing the problem.
This makes it possible to observe:
- 🧠 What different models notice
- 🔍 Details one model catches that another misses
- 💡 Different approaches to the same problem
- 🤝 How those perspectives inform the aggregator
It’s a useful reminder that different LLMs don’t always approach problems in exactly the same way.
And that’s where the potential value of Mixture of Agents comes from.
You don’t necessarily need three models to agree.
Sometimes the disagreement is the useful part.
🎛️ One Configuration That Can Make a Big Difference
One setting worth understanding is:
reference_max_tokens
This controls how much output each reference model can generate for the aggregator.
Giving every advisor thousands of tokens isn’t necessarily useful.
The aggregator often needs the key insights, not another complete solution.
Lower limits can therefore mean:
- ⚡ Faster responses
- 💰 Lower token usage
- 🎯 More focused advice
- 📉 Less unnecessary context for the aggregator
Hermes recommends 600 tokens as a practical default for concise reference responses, though the ideal value will depend on your task.
🧩 Different AI Teams for Different Problems
Another feature I found useful is the ability to create multiple Mixture of Agents presets.
That means you don’t need one universal AI team.
You could have:
💻 Coding
Models selected specifically for software engineering.
🔬 Research
Models with different strengths in analysis and long-context reasoning.
🏗️ Architecture
Models that provide complementary perspectives on system design.
📈 Financial Analysis
A completely different combination optimized for analytical tasks.
Instead of constantly asking:
“What’s the best AI model?”
The more interesting question becomes:
“What’s the best combination of models for this particular problem?”
🎯 When Does Mixture of Agents Actually Help?
I wouldn’t enable Mixture of Agents for every prompt.
If you’re asking:
What’s 15 × 27?
Three AI models aren’t going to make the answer three times better.
The additional reasoning becomes valuable when there are multiple valid approaches to a problem.
Some good candidates include:
- 🏗️ Software architecture
- 🔍 Code reviews
- 🐞 Complex debugging
- 📚 Technical research
- 🔄 Migration planning
- ⚙️ System design
- 🤖 AI agent workflows
These are problems where a second or third perspective can expose something the first model overlooked.
⚖️ The Trade-Offs
Mixture of Agents isn’t a free intelligence upgrade.
💰 Higher API Costs
You’re making additional model calls.
With two reference models and one aggregator, you’re paying for multiple perspectives instead of relying entirely on one model.
Hermes preserves prompt caching, which helps, but the additional reference calls still introduce extra cost.
⏳ Increased Latency
The aggregator needs the reference outputs before it can use them.
That means complex tasks can take longer than simply sending everything directly to one model.
🤔 More Models ≠ Better Results
Adding models blindly isn’t the goal.
If all your reference models have similar strengths and approach problems similarly, the additional perspectives may not add much.
The real value comes from diversity.
A strong combination might include models that excel at different things rather than simply choosing the three highest-scoring models on a leaderboard.
💡 The Bigger Idea: AI Models Don’t Have to Compete
The most interesting takeaway for me wasn’t the Kanban application itself.
It was the change in how we can think about AI models.
Most of the AI industry conversation revolves around competition:
Which model is #1?
Which model has the highest benchmark score?
Which model should replace the one I’m currently using?
But maybe that’s only part of the story.
The next step in AI systems might not simply be:
One smarter model.
It could also be:
Multiple specialized models working together.
Instead of choosing between Claude, DeepSeek, MiniMax, GPT, or whatever comes next, AI agents can potentially use different models as a team—taking advantage of their individual strengths before making a final decision.
The question then changes from:
“Which AI model is the smartest?”
to:
“Which combination of AI models makes the smartest decisions?”
And I think that’s a much more interesting problem.
💬 Which 3 AI Models Would You Choose?
Here’s the experiment I’d love to see:
You get to build your own AI team.
You can choose two advisors and one final decision-maker.
Which three models are you picking?
And more importantly:
Why that combination?
Drop your AI team in the comments. 👇
SOCIAL SHARE CARD GENERATOR