Common Ground

Inspiration

Every friend group knows the deadlock: three people, twenty messages of "anything is fine," and nobody picks dinner. Generic chatbots make it worse - they average the group into bland, hallucinated suggestions nobody is excited about, and they can't explain why a pick fits each person.

The interesting version of this problem is cross-domain: nobody in the group shares a favorite, so the answer can only come from taste adjacency - the fact that people who love X tend to love Y. That adjacency is exactly what Qloo's taste graph provides and what an LLM alone can only fake. I built Common Ground to prove that an agent grounded in real taste data can break the deadlock honestly.

What it does

Each person lists a few things they love - artists, films, dishes. The agent:

1. Grounds each like to a real entity with Qloo Entity Search (disambiguation is shown, not hidden).
2. Detects taste clashes - when the group shares no domains, it says so and leans fully on cross-domain affinities.
3. Pulls candidates from Qloo Insights using the union of everyone's taste signals, per domain (dinner / movie / playlist), places filtered to the chosen city.
4. Re-runs Insights per member to attribute which member's signal each candidate leans toward - that's what powers the honest "why this works for Mia" rows.
5. Scores candidates by maximin: the winning pick maximizes the least-excited member's affinity. The goal is a compromise the whole group can accept, not a pick one person loves and another vetoes. Members with no Qloo signal count at a cautious 50% prior - never ignored, never faked.
6. Replans around pushback: veto a pick and it's excluded; "make it cheaper" applies a price filter; the whole loop re-runs.

Consensus is explicit: each person answers "I'm in" for themselves, and the app only declares the deadlock broken when everyone actually has. Multi-device by design - the exact proposal travels in a share link, so everyone votes on the same plan from their own phone; votes bind to the plan and a changed plan invalidates them. No accounts; session state is not stored on the server - it travels in the share link. Votes are deliberately sequential and self-reported - honest for friend groups, not an authenticated ballot.

The entire agent loop is rendered as a full step-by-step execution trace, because an agent you can't watch is just a form.

How we built it

• Static frontend (no framework, no build step) + serverless Node API on Vercel.
• All Qloo traffic goes through a server-side proxy; the API key never touches the browser.
• Qloo endpoints used: Entity Search for grounding, Insights with signal.interests.entities (union and per-member), filter.location.query for city, filter.exclude.entities for vetoes, filter.price_level.max for budget, feature.explainability=true for provenance.
• No personal data leaves the app: only entity IDs and taste tags are sent to Qloo. Affinities are presented as aggregate cultural associations, never as predictions about an individual.

Evaluation (honest numbers)

A reproducible 10-scenario harness (scripts/evaluate.mjs) compares the taste-aware plan against a popularity-only baseline over the same Qloo catalog: the group pick differs from the generic "top picks near you" answer in 30/30 domain comparisons, and every dinner pick is a real restaurant in the chosen city. A same-candidate-pool benchmark (scripts/benchmark.mjs, fixed 30-scenario suite) scores the final pool three ways: maximin ties a prior-adjusted arithmetic mean 30/30 (we report the null, not a win) and differs from a naive mean-of-known baseline in 15/30 cases. The limitations are documented too: scripted scenarios are not human testers or proof of real-group satisfaction, and about half of member-pick pairs have no per-member Qloo signal (counted at the cautious prior, visible in the table).

Challenges

• Grounding is hard. Free-text likes like "techno" or "sushi" resolve to people or places before genres; the resolver prefers non-person matches and shows its choice in the trace.
• Fairness is a scoring problem. A naive group average hides the miserable member. Maximin plus an uncertainty prior makes the compromise visible and honest.
• Multi-user without infrastructure. No database, no accounts: the session serializes into the URL, so real multi-device consensus works with zero storage and zero personal data.

Accomplishments

• A working agent, live on real Qloo data, that produces a concrete dinner + movie + playlist plan with per-person rationale in seconds.
• An honest control group: a one-click comparison against the popularity-only baseline, so the value of taste data is demonstrated, not claimed.
• A reproducible evaluation harness with documented limitations.

What we learned

Cross-domain affinity is the real unlock for group decisions - shared favorites almost never exist, but taste adjacency always does. Also: an agent's reasoning shown live builds more trust than any accuracy claim.

What's next

Simultaneous multi-user sessions, booking/queue integration to close the loop from decision to reservation, and a real-group study to measure how often the maximin pick beats the group's own first idea.

Built With

• explainability)
• insights
• javascript
• node.js
• qloo-taste-ai-api-(entity-search
• vanilla-html/css
• vercel-serverless-functions