Tonight’s Pick

Inspiration

Taste and reception are different questions. Qloo knows taste: that fans of Hereditary also like The Witch. It can't tell you whether ordinary viewers walked away happy. Review scores know reception, but not whether you'll like it. "What should we watch tonight?" needs both, and for couples and friends it needs both for everyone in the room.

What it does

Tonight's Pick recommends three movies or shows you haven't seen, that fit your taste (Qloo), and that real viewers liked (our Real People Score, read from public comments and judged within each genre).

• Ask in plain words: "a fun family movie about Halloween, under 2 hours". You get three picks that really are about Halloween, each with its score, a fact-checked "why it fits you", and where to stream it.
• "How we picked this" lists every agent step and every Qloo call, with its status, result count, speed and what was sent (only titles and tags, never personal data).
• Pick together (2–5 people): everyone joins one link with their own likes. Each person's likes become their own Qloo signal; qloo_rank runs once per person, and we keep the titles with the best worst rank, so the least-excited person still likes it.
• Taste match between friends ("Sam & Alex: 82%"), built from the Qloo tags of what each liked, plus shareable cards.
• Also: voice through an MCP server, streaming-service and language filters, and "Rising this week" from Qloo trends.

How we built it

Qloo tools, and why each one:

Implementation details:

• The harness: Qloo is called only through the official harness (@qloo/qloo-harness, one long-lived qloo mcp process), only from the API server, never from the browser.
• Logging and caching: every call is logged (redacted) and cached for 24 hours.
• Result statuses: all six are handled; needs_input becomes a question for the user.
• The agent runs on NVIDIA Nemotron (Nebius). The server checks every answer: picks must come from tool results, meet every constraint, and clear a reception floor.

A real request, start to finish ("Fun family movie about Halloween, under 2 hours"):

1. get_user_context: the user's likes, dislikes and seen titles.
2. qloo_find_tags("fun family Halloween") → 5 tags, including urn:tag:interests:qloo:halloween, urn:tag:october_event:qloo:halloween and urn:tag:october_event_type:qloo:family.
3. qloo_recommend (20 results, with those signal tags) plus well-known TMDB titles tagged "halloween" → 40 candidates.
4. apply_constraints(max_runtime: 120) → 20 kept, 20 dropped. The server also checks the topic and a PG rating for "family".
5. Real People Scores for the 20 survivors.
6. qloo_entity_tags on the top 3 to explain the fit.
7. Result:
   • The Nightmare Before Christmas (89% liked), It's the Great Pumpkin, Charlie Brown (91%), The Adventures of Ichabod and Mr. Toad (82%).
   • Introduced as "Here are 3 family-friendly movies about Halloween, under 2 hours and rated PG or under."
   • Cost: 6 Qloo calls, about 46,000 tokens, about 1.5¢, 11 seconds.

The rest of the stack: Node/Fastify, Prisma and Postgres (Neon), pg-boss, Next.js on Vercel, TMDB, the YouTube Data API and Bluesky.

Challenges we ran into

• The hackathon server setup. Pointing the harness at hackathon.api.qloo.com needed both QLOO_BASE_URL and QLOO_TRUSTED_BASE_URL. Over MCP the trust error only showed as "connection closed". (It's in our friction log.)
• Tag-only requests lean obscure. "Something funny" with no liked titles returned little-known catalog items. We add well-known TMDB titles that meet the request and let Qloo rank everything by taste.
• Entity tags mix kinds. Music genres and brand themes showed up as "why it fits you" ("Brand Building"). We keep only descriptive tag types (genre, style, archetype, motif, keyword, mood, plot).
• Groups:
  • Recommending only from everyone's combined signals let the strongest taste dominate, so we build a balanced pool (together plus each person).
  • Rank scores from separate qloo_rank calls aren't comparable, so we use each person's order.
• Topics are hard filters. Qloo's taste matches rarely carry a specific topic, so topic candidates come from TMDB keywords, and Qloo ranks them.

Accomplishments that we're proud of

• Seven Qloo tools in one product, each with a clear job, all visible to users in "How we picked this".
• Pick together for up to five people: a per-person qloo_rank, deciding by the least-excited person.
• Taste match and share cards that make taste social.
• Every claim is checked by the server, including the "why it fits you" line, which only cites tags the title genuinely shares with your likes.

What we learned

• Qloo is strongest with entity signals (titles you liked). Tags shine for steering, while entities carry taste.
• Taste plus reception beats either alone. Qloo picks what's yours, and real viewers' opinions pick what's good.
• Showing users every call ("How we picked this") made us build better: anything we couldn't explain, we fixed.

What's next for Tonight's Pick

• Publish the evaluation: agent vs. a plain chatbot on hallucinated titles, already-seen titles, constraint violations and reception of picks. The harness is in docs/eval.
• Taste over time: a weekly "your picks" email, Wrapped, and taste history between friends.
• More platforms: voice on Alexa+ and Fire TV, and AI-assistant apps (ChatGPT, Claude) through the same MCP server.

The same codebase is also entered in the Amazon (Alexa+) and Nebius x NVIDIA hackathons. MIT licensed: github.com/gunnerhowe/TodaysWatch · Live: https://todays-watch.vercel.app

Built With

• bluesky
• docker
• fastify
• model-context-protocol
• nebius
• neon
• next.js
• node.js
• nvidia-nemotron
• openai-sdk
• pg-boss
• playwright
• postgresql
• prisma
• qloo
• qloo-harness
• railway
• react
• tailwindcss
• tmdb
• typescript
• vercel
• vitest
• youtube-data-api
• zod