ConsensusAI — Making Group Decisions Fair, One Agent at a Time

Inspiration

We've all been in that group chat where everyone wants to hang out, but nobody can agree on where to go, when to meet, or how much to spend. One person wants sushi, another has dietary restrictions, someone is on a budget, and someone else isn't available. Eventually, either the plan falls apart or one person ends up compromising more than everyone else.

We wanted to build something that actually solves this problem.

What if, instead of endlessly negotiating in a group chat, everyone had their own AI agent that understood their preferences and could negotiate on their behalf?

That's the idea behind ConsensusAI: a multi-agent group-planning system designed to find plans that work for everyone, not just the loudest person in the group.

What It Does

ConsensusAI gives each participant a personal AI agent that understands their preferences, including budget, dietary restrictions, favorite cuisines, travel distance, and availability.

When someone initiates a group plan, the agents collaborate to evaluate possible options and reach a fair recommendation.

But there's a twist: ConsensusAI doesn't just maximize the group's average happiness. It prioritizes fairness.

We use a leximin-based decision algorithm that considers the least-satisfied participant first, helping prevent situations where three people are happy but the fourth gets a terrible deal.

And when the agents can't reach an agreement, they don't simply give up. They can identify a specific conflict and privately negotiate a possible exception with the affected participant. The person stays in control and must explicitly approve any proposed preference change.

We built two ways to interact with ConsensusAI:

• ASI:One: Our primary multi-agent interface, where independently running Fetch.ai agents communicate, evaluate options, negotiate, and reach consensus.
• iMessage: A companion interface powered by Photon that lets users interact with ConsensusAI through familiar text messages, manage preferences, and coordinate group outings.

How We Built It

We built ConsensusAI primarily in Python, combining several technologies:

Fetch.ai uAgents and ASI:One

We created four independently running personal agents—Alex, Maya, Jordan, and Sam. Each evaluates proposed restaurants against its owner's constraints and preferences, then communicates its evaluation to a coordinating agent.

The coordinating agent gathers their responses and runs the fairness algorithm to determine the best group recommendation.

StepFun for Natural-Language Understanding

Users can express preferences conversationally, like:

"I'm vegetarian, I love Mediterranean food, and I don't want to spend more than $30."

StepFun interprets the request and converts it into structured preference updates. The agent shows the proposed changes and asks for confirmation before saving them.

Google Places API

We integrated live restaurant discovery so ConsensusAI can evaluate real locations rather than relying entirely on hardcoded examples.

Leximin Fairness Algorithm

We implemented deterministic constraint checking and fairness-based ranking. Hard constraints eliminate unacceptable options, while soft preferences help score the remaining candidates.

The system prioritizes the worst-off participant when comparing feasible plans, rather than blindly choosing the restaurant with the highest average score.

Private Multi-Agent Negotiation

When no feasible option exists because of one participant's negotiable constraint, the coordinator can request a private counteroffer from that person's agent.

We also implemented proactive ASI:One notifications, allowing the personal agent to contact its owner directly for approval without requiring them to manually check for pending negotiations.

Once approved, all four agents evaluate the updated situation again.

Photon, iMessage, and PostgreSQL

We built a companion iMessage experience using Photon, with PostgreSQL-backed user preferences, group membership, invitations, and planning state.

The iMessage interface currently uses a centralized coordination service that shares our preference, venue-search, scoring, and fairness components. Our distributed agent-to-agent negotiation workflow operates through ASI:One.

Browser Use

We integrated an optional browser-based availability-checking workflow to explore restaurant reservation options without automatically completing a booking or payment.

Challenges We Faced

Getting independent agents to communicate reliably

Building one AI assistant is straightforward compared with coordinating four independent agents. We had to handle asynchronous responses, timeouts, incomplete evaluations, and making sure the coordinator didn't produce a recommendation before receiving everyone's input.

Balancing fairness with feasibility

A restaurant might have an excellent average score while being completely unacceptable to one participant. We needed to separate hard constraints from preferences and implement a fairness algorithm that respected both.

Making negotiation practical

Initially, our counteroffer workflow worked, but users had to manually retrieve pending requests. We discovered issues with ASI:One conversation-session routing and implemented proactive notifications so an agent could reach out to its owner directly.

Managing preferences safely

We had to distinguish natural-language requests from confirmed preference changes, validate model-generated updates, and ensure that private preferences weren't exposed to other agents during coordination.

Integrating multiple platforms

Connecting Fetch.ai, StepFun, Google Places, Photon, PostgreSQL, and Browser Use introduced different messaging protocols, asynchronous workflows, persistence requirements, and deployment challenges.

We also learned the importance of testing each integration independently before putting everything together.

What We Learned

One of our biggest takeaways was that multi-agent systems are most interesting when agents have different goals and constraints, rather than simply performing different tasks.

We learned how to design agent-to-agent communication, manage asynchronous workflows, implement private human-in-the-loop negotiation, and combine LLM-based natural-language understanding with deterministic decision-making.

We also learned that good AI products need more than intelligent models. They need reliable infrastructure, understandable explanations, and user experiences that make the intelligence genuinely useful.

What's Next

We want ConsensusAI to grow beyond restaurant planning into a general-purpose group decision-making assistant.

Imagine using it to coordinate trips, select activities, plan events, or make shared purchasing decisions—all while respecting everyone's preferences.

Our next priorities include connecting the iMessage experience directly to the distributed agent network, supporting dynamic participants and scheduling, improving long-term preference memory, and introducing one-time versus permanent negotiation exceptions.

Ultimately, we envision a world where personal AI agents don't just answer questions for individuals—they collaborate with other people's agents to help groups make better, fairer decisions.

Less arguing. Less compromising. More consensus.

Built With

• ai-agents
• asi:one
• asyncio
• browser-use
• fetch.ai
• google-maps-platform
• google-places
• imessage
• leximin
• multi-agent-systems
• natural-language-processing
• photon
• postgresql
• psycopg
• python
• rest-apis
• stepfun
• tigerdata
• uagents
• vultr