Verdict

An agentic system on Qloo's taste graph that made GPT-6 Astra better, and puts every festival timetable clash on trial before a court of AI agents, with code as the final judge

Comment

Verdict: putting festival clashes on trial

At a glance: a four-agent court that resolves real festival timetable clashes using Qloo's taste graph, with deterministic code as the final judge. In 28 pre-registered tests (26 run to a result), Qloo made GPT-6 Astra measurably better: 0/30 → 29/30 on real Friday closing times at 30 NYC restaurants, 0.697 → 0.728 on ranking real shared fans (significant). The court cut a real Lollapalooza day's clashes by 45% (10.85 → 5.92) with zero festival rules broken, refusing 15 rule-breaking agent proposals along the way.

Try it: live demo · 2-minute self-playing tour · code · everything in one file (llms.txt)

Inspiration

Every festival-goer knows the moment: two artists you love, two stages, the same hour. You choose one, miss the other, and walk away asking the obvious question: why didn't anyone see this coming?

The answer is structural. Festivals publish timetables that put shared-fan acts against each other all the time, because nobody puts a number on shared audiences before tickets go on sale. Promoters hit the same blind spot: shows that draw the same people land on the same night or week and cannibalise each other. And fans plan days around a handful of artists with no help joining them up.

"Which acts share fans" is not a fact you can look up. It's a taste graph problem. When Qloo announced an agentic hackathon, the pieces clicked: the taste graph exists, and modern agents can act on it, but only if something decides which moves are safe. That something became the court.

What it does

Verdict turns the hidden fact, which acts draw the same people, into a measurable objective, then puts AI agents to work on it.

The clash score for a festival bill $B$:

$$S(B) = \sum_{{a,b} \subseteq B} w(a,b) \cdot \mathrm{overlap}(a,b)$$

where $w(a,b) \in [0,1]$ is the shared-fan weight from Qloo's artist-to-artist affinity (ranked within the bill, both directions averaged, then cubed so near-twins dominate), and $\mathrm{overlap}$ is the hours the two sets run at the same time. Lower is better. A red clash is any pair with $w \geq 0.45$ whose sets overlap.

Around that score, Verdict serves three audiences, plus the evidence:

  • Festivals get a timetable rebuilt by a court of four AI agents: two fan agents argue, a booker objects on rule grounds, a judge rules, and deterministic code refuses anything that breaks a rule or doesn't improve the day. The human booker can overrule the judge, type emergencies in plain words ("Tyla just cancelled"), or drag any set and watch its clashes light up.
  • Promoters get which nights compete for their artist's fans (a calendar heat map over real Ticketmaster listings), which of their own shows cannibalise each other (Live Nation's real New York month holds 51 same-fan pairs within a week), which openers fit, and a tour route with the least contested night in each city.
  • Fans get a festival day and a month of nights out planned around the artists they love, each night a timetable: a place to eat before, the show, a bar after, matched by Qloo to the group's music taste and filtered by Qloo's opening hours.
  • Judges get a Why Qloo page where every claim is an interactive chart, with exact numbers and intervals on hover.

How we built it

We pre-registered before we built. The most important decision we made was to write down each test's question, data, metric and decision rule, and commit them to git before writing the code that would produce a result. 28 tests over 22 days (Oct 9 to Oct 30, 2026; 26 run to a result), scored against real-world data outside Qloo, on two model families, with 95% bootstrap intervals. It was slower. It was also the only way to avoid running ten tests and reporting the three that worked.

Test Without Qloo With Qloo
Ranking pairs of acts by real shared listeners, GPT-6 Astra 0.697 0.728 (significant)
Same, Gemini 3.8 Flash 0.695 0.723 (significant)
Friday closing times, 30 real NYC restaurants, GPT-6 Astra 0/30 29/30
Same question asked twice: pair scores that changed up to 46 of 903 0
Timetable quality, Qloo vs popularity 0.043 0.663

All 28 tests, one line each (registered before any result; 26 run to a result):

# Question Result
1 Do Qloo cuisine heatmaps predict where a cuisine's first restaurant opens? No (city density does better)
2 Do music-audience heatmaps carry residents' taste? No
3 Do Qloo-grounded briefs beat plain ones, by blind human raters? Not completed
4 Does Qloo add to city records for ranking leases? No
5 Does Qloo predict which young restaurants survive? No claim (a placebo gained as much)
6 Do Qloo audience tags match independent data? 2 of 7 hold
7 Does Qloo predict which cuisine opens at a storefront? No added value
8 Does Qloo add to a brief beyond a list of nearby businesses? No
9 Do improved Qloo briefs beat city-record briefs? Not shown
10 Does Qloo's competitor list cover city records? 37% coverage, 81% exist
11 Is a Qloo scene about the restaurant or its location? Mostly location
12 Are Qloo's Friday closing times right (vs Google Maps)? 29 of 30
13 Which uses of Qloo's graph are stable enough to test? 3 of 7 pass
14 Does Qloo venue-to-artist affinity match real bookings? Above popularity
15 Does Qloo artist-to-artist affinity match real tour bills? 0.875, above popularity and genre
16 Does a model find real openers better with Qloo? No difference
17 Do Qloo city scores match where artists play? Not above city size
18 From five loved films, does Qloo find the next? Above popularity and genre
19 Does Qloo lift models on another team's 115 tours? Not run (needed model credit)
20 Is a model right about closing times more often with Qloo? 0/30 to 29/30
21 Is Qloo ahead on lesser-known headliners? No
22 Does Qloo find the places a model names? 119 of 120
23 Does Qloo know which comedians share a crowd? Not shown
24 Does Qloo's age skew find acts young people took up? No
25 Qloo on its home ground: small acts, new restaurants, steadiness Steady; no gain on new restaurants
26 Do Qloo city scores predict MLB theme-night attendance? No
27 Does Qloo find small artists real listeners play? 0.841 vs popularity 0.516
28 The clash score: which scorer best ranks pairs of acts by real shared listeners (10 bills of 30 artists, Last.fm), and builds the best timetable? Qloo made GPT-6 Astra (0.697 to 0.728) and Gemini (0.695 to 0.723) better; Qloo 0.663 vs popularity 0.043 on timetables

Then the engine. Qloo is used four ways: /search for exact-name identity, and /v2/insights for artist-to-artist overlap, fan-to-artist fit, and music-taste-to-places with opening hours. The Qloo client caches every reply and reads X-Month-RateLimit-Remaining live, so we never blow the quota. The optimiser is a constrained local search (12 seeded runs inside a 2-second budget) that respects the house rules (headliners close, moves within 2 hours, set lengths and stage sizes kept) and pins anything the agents or the human booker have decided.

Then the court. For each red clash, worst first:

  1. Two fan agents run in parallel with tools fans_of and moves_for. They are allowed to propose rule-breaking moves, because fans don't care about house rules.
  2. A booker agent checks every proposal with check_move and legal_moves, objects by naming the rule, and may counter-propose a legal move.
  3. A judge agent weighs the checked proposals (with score_move) and rules.
  4. The clerk, deterministic Python, refuses any ruling that breaks a rule or doesn't improve the day, then applies the accepted move at once, so the next case is argued on the new timetable.

That is the whole architecture in one sentence: agents propose and argue, code decides. Nothing an agent says can break a festival rule.

Then the extensions. The same Qloo pair table powers book-a-date (each night's fan pull), the promoter portfolio (compete, sequence, co-promote), openers (the model proposes, Qloo verifies), and fan evenings (Qloo places within 900 m, filtered by Qloo's hours). Five cities are loaded ahead for the demo: New York (386 shows on sale), Chicago (203), Los Angeles (278), Boston (142) and San Francisco (163). Every other US city works the same way and loads on demand. A 10-tool conversational agent wraps the whole engine, shows each tool call as it runs, and flags any figure in its answer that doesn't trace back to a tool result.

The stack. FastAPI on the server, vanilla JS with D3 and Leaflet on the client, server-sent events for streaming the court and the agent live, GPT-6 Astra through CometAPI (Kie, OpenRouter and OpenAI are one-setting drop-ins), and a private cache loaded onto the host at start-up, so Qloo data never enters the public repo.

Challenges we ran into

Most of our ideas failed, badly, and we kept going. We didn't start with festivals. We started with restaurants and neighbourhoods: could Qloo's area heatmaps predict where a cuisine opens next? No (Test 1). Could music-audience maps reveal what residents like? No (Test 2). Could Qloo improve lease picks, restaurant survival, positioning briefs or competitor lists? No, no, not shown, 37% coverage (Tests 4 to 10). Then Qloo's city scores for tours, its age skew, comedians, MLB theme nights: no, no, not shown, no. Test after test came back flat. Each failure was registered before we saw it, so we couldn't talk ourselves out of it. What survived was narrow and real: Qloo knows which artists share fans (Tests 15, 27, 28) and real facts about places (Tests 12, 20, 22). Verdict is built on exactly those two things.

Finding the real world was hard. Real data doesn't come clean: published festival timetables with typos and duplicate listings, Ticketmaster listings full of add-ons and tribute nights, opening hours a person had to read off Google Maps by hand, and real listening data to judge against. And many of the small artists on real bills aren't in Qloo at all (14 to 19 of 43 acts on the 2026 days), so we fill them from Last.fm, labelled, and never guess.

Keeping a frontier model running. Testing against GPT-6 Astra, one of the most powerful reasoning models available, meant paying for it: provider keys expired, credit ran out mid-test more than once, and a test that ran out of credit was registered and reported as not run (Test 19). We built the system so most features need no model at all, and the agents' sittings are recorded once and replayed free.

The first version wasn't agentic enough. The agents narrated the optimiser's choices. We rebuilt the court with parallel fan agents, a booker with real tool boundaries, a judge with a scoring tool and a code gate, because the earlier version would not survive a judge asking "what did the model actually decide?"

A broken recording looked like a real one. Early on, a sitting was saved while the model provider was refusing calls. We learned to never save a sitting where any agent failed, and added a quick-ruling (optimiser-only) fallback, clearly labelled. The recording on the site is one we trust.

Latency was round trips, not thinking. Early live cases took about 30 seconds, mostly agents waiting on tool calls. Briefing each agent with its first tool results up front means most answer in one trip, and streaming shows text as it's written. Live cases now take about 18 seconds, and the recorded replay is instant and free.

Pre-registration caught us being wrong. Qloo's area heatmaps didn't predict where a cuisine opens (Test 1). Music-audience maps didn't carry resident taste (Test 2). Qloo added nothing to lease and survival data (Tests 4, 5, 7). Qloo-grounded briefs didn't beat briefs from city records (Tests 8, 9). Without pre-registration we would have quietly dropped those. Instead they shaped the product: Verdict is built on artist-to-artist overlap and place facts because the other applications failed.

Accomplishments that we're proud of

  • We found a real-world use case where Qloo genuinely makes AI better, and proved it. That was the hardest part. After many ideas failed under honest testing, we found the one where a taste graph changes the outcome: keeping fans who share a taste from being forced to choose, and planning their nights around real places.

  • We tested extensively, across models and use cases. 28 pre-registered tests over 22 days, two model families (GPT-6 Astra and Gemini 3.8 Flash), against real data outside Qloo: restaurants, neighbourhoods, venues, tours, films, comedians, sport, festivals and listeners.

  • Qloo made a frontier model better, and a small model with Qloo scored above it. GPT-6 Astra went from 0.697 to 0.728 with Qloo, a significant gain. With Qloo, the small Gemini 3.8 Flash reached 0.723, above GPT-6 Astra alone.

  • The determinism number. Between two identical requests, GPT-6 Astra changed its pair scores by 10+ points on up to 46 of 903 pairs. With Qloo: 0 of 903. A clash score that gives the same answer every time.

  • Facts the model can't know. Asked when real restaurants close on Friday, GPT-6 Astra alone got 0 of 30. With Qloo: 29 of 30.

  • The code gate. 15 rule-breaking proposals refused, 0 rules broken. The court is real because the clerk is real.

  • The honesty. Both scores shown, ties reported, and where the model is better (openers, tour order) it leads and Qloo checks its picks.

  • 28 pre-registered tests over 22 days, two model families, 95% intervals, negative results included. That's the part we think will hold up longest.

What we learned

A taste graph doesn't replace a frontier model. It makes one better. On taste alone, Qloo and GPT-6 Astra were level. Together they beat GPT-6 Astra alone, significantly, on real shared fans (0.697 → 0.728). With Qloo, even the small Gemini 3.8 Flash scored above GPT-6 Astra on its own. The winning architecture isn't Qloo or the model. It's the model, grounded by Qloo.

Models are brilliant at reasoning and blind to the real world. GPT-6 Astra couldn't name one real restaurant's Friday closing time (0 of 30). With Qloo it got 29. Agents that act in the world need a source of real-world truth, and that's exactly what Qloo is.

Finding where AI actually helps is the hard part. Most of our ideas failed under honest testing. The breakthrough wasn't a clever prompt: it was 28 tests narrowing a huge space down to the two things Qloo does better than anything else, which artists share fans and real facts about places, and then building only on those.

Pre-registration is a product feature, not a chore. Writing the decision rule before the result kept us honest about what Qloo does and doesn't do. The negative results are the proof the 28 tests were real.

Determinism is a feature people will pay for. A festival booker can't defend "the model said 5.92 today and 6.4 yesterday" to an artist's manager. Asked twice, a model changed 46 of 903 answers. Qloo changed none.

Code as the final judge makes agents more powerful, not less. Because the clerk refuses anything that breaks a rule, the fan agents can argue freely for anything their fans want, and 6 of the court's 9 moves were ones an optimiser alone would never have found. The gate is what makes the argument safe.

Honesty is the strongest signal. Showing that the court scores slightly worse than the optimiser, and saying why, earns more trust than any number we could have hidden.

What's next for Verdict

Next:

  • Re-run Test 28 against more frontier models. If Qloo's gain holds at the top end, that's the strongest version of the story. If it shrinks, we'll say so.
  • Validate the clash score against real ticket-sale data. We have the schedule side, not the sales side, and it's the test we most want to run.
  • A pilot with a real festival's booking team, with multi-day timetables and artist travel constraints.

Then:

  • Every US city live, with alerts when a competing show goes on sale.
  • The clash score and fan pull as an API for ticketing platforms.
  • A fan app with real-time "who's on now that you'd love" alerts at a festival.

The business model is a plan, not a validated business: festivals pay per edition, promoters a monthly subscription, ticketing platforms per API use, and fans get the planner free, with partner bookings at restaurants and bars. In a $40B+ live music market (Omdia), every timetable, booking and marketing decision depends on which acts draw the same people. We want that to be a number, not a guess.

What we deliberately didn't build: a mobile app (the site works at phone width), accounts or personal data (nothing is stored), and every US city loaded ahead. Scope discipline is what let us finish the court and the 28 tests in three weeks.

Qloo measures, the agents argue, code decides, and when the court loses to the optimiser, we tell you.

Team: Athmeeya M Kashyap and Siddhant Gudwani · Qloo Agentic Hackathon 2026

Built With

Share this project:

Updates

Submission history