Sponsorship Scout

An agent that tells a brand which podcasts, artists, shows and creators to sponsor, grounded in what its customers already love on Qloo's taste graph.

Comment

Try it

Inspiration

Sponsorship is a guessing game. A brand picks a podcast because the host is famous, or a festival because a competitor was there, and finds out months later that the audience never overlapped with its customers. Agencies answer this with expensive panel surveys. A language model on its own can't answer it at all: ask one which podcast a hiking-boot brand should sponsor and it names the most popular shows it has heard of, with no idea who actually listens.

Qloo's taste graph holds exactly the missing fact, which is what a given brand's customers also love across podcasts, music, TV, people and other brands. So we built an agent that looks it up instead of guessing.

What it does

You type a brand name. Sponsorship Scout researches the brand's customers in Qloo's taste graph, shortlists sponsorship targets, checks each one, and returns a ranked report with pitch emails ready to send.

Each report contains:

  • Ranked picks across podcasts, artists, TV shows, people and creators, each with its Qloo fit score, audience demographics and the reasoning behind the ranking.
  • Mutual fit checks: whether the candidate's own audience favours the brand back, not just the other way round.
  • What was ruled out and why, so you can see the agent's judgement, not just its conclusions.
  • Partner brands whose audiences overlap, for co-marketing.
  • Pitch emails drafted for the top picks, citing the audience evidence.

The browser shows every step live while the agent works: each Qloo lookup, what came back and what the agent decided to do next.

Why it is Qloo-powered

Every name and every score in a report comes from the Qloo API. The agent has four Qloo tools:

  • Search finds the brand and its Qloo entity ID.
  • Insights returns what the brand's audience favours in each category (podcasts, artists, TV shows, movies, people, video games, books, brands) with affinity scores.
  • Demographics gives the age and gender skew of the brand's audience and of each candidate's audience, so the agent can compare them.
  • Reverse insights check whether a candidate's audience favours the brand, which is the difference between a plausible sponsorship and a good one.

Without Qloo there is no report. The server enforces this: every pick the agent submits is checked against what Qloo actually returned, names, images and fit scores are filled in from the lookups rather than from the model, and a pick the agent can't back with a lookup is rejected and sent back to it to fix. The model supplies judgement and prose; Qloo supplies the facts.

How we built it

  • Agent loop (src/agent.ts): a tool-calling language model, called through OpenRouter, with the four Qloo tools above and a structured submit_report tool. The model is configurable via SCOUT_MODEL; the deployed app runs on a small, cheap model to show the grounding does the heavy lifting, not model size.
  • Research strategy: the agent first finds the brand and learns who its customers are, then explores what those customers love across several categories in parallel, then vets the shortlist (mutual fit, demographic match, reach) before writing up.
  • Verification layer (buildReport in src/agent.ts): checks the submitted report against the Qloo responses recorded during the run and rejects unsupported claims with a message the agent can act on.
  • Live progress (src/server.ts): the Node server streams agent events to the browser over server-sent events, so you watch the research happen.
  • Qloo client (src/qloo.ts): a thin typed wrapper over Qloo Search and Insights that records every entity and fit score it sees, with a per-run lookup budget.
  • Stack: TypeScript on Node 22, no framework, static HTML front end, deployed on Render.

Challenges we ran into

  • Silent failures in the Insights API. Invalid parameters are ignored rather than rejected, so an unusable query returns a confident, generic answer. We fixed this by giving the agent a fixed list of categories that map to valid Qloo entity types, validating every tool input on the server, and capping lookups per run so a confused model can't loop.
  • Keeping the model honest. Early versions happily invented a podcast name when a lookup came back thin. Moving the facts out of the model's hands and into the verification layer solved it: the model can only rank and explain entities Qloo returned.
  • Making a two-minute agent run feel alive. Streaming each tool call and result to the page turned a loading spinner into the most interesting part of the demo.

Accomplishments that we're proud of

  • A report where every claim is traceable to a Qloo lookup, with no hallucinated entities.
  • Reverse insights as a first-class check. Most sponsorship advice stops at "your customers like X"; Scout also asks whether X's fans like you.
  • Running on a cheap model end to end, which shows that cultural data, not model scale, is what makes the agent useful.

What we learned

A language model with good tools and a strict verifier beats a bigger model with no data. Qloo's affinity scores and demographics gave the agent something concrete to reason about, and the gap between its grounded picks and an LLM's unaided guesses was obvious in the first test.

What's next for Sponsorship Scout

  • Location-aware picks using Qloo's geo filters, for regional campaigns and live events.
  • Budget tiers, so the agent balances reach against cost and suggests a portfolio rather than a list.
  • Exporting reports and pitch emails straight to a CRM.
  • A reverse mode for creators: given a podcast or artist, which brands should they pitch?

Built With

Share this project:

Updates