GigRoute

Routes an independent band's tour to where its fans already are, using Qloo taste data. NVIDIA Nemotron on Nebius Token Factory writes up why the route works.

Comment

Inspiration

Independent musicians plan tours on gut feel: the cities where friends have couches, or the venues whose booker happened to reply. Then they play half-empty rooms far from the crowd that would have loved them. Big acts have agents and data teams; small acts have a spreadsheet. We wanted to give a band with a van the same audience data, and a planner that explains itself.

What it does

You enter an artist (or a better-known artist you sound like) and a region. GigRoute's agent streams a tour plan step by step:

  • Fan hotspots: cities where audiences with your taste over-index, in a drivable order on a map.
  • Rooms per city: venues, bars and record shops ranked by audience affinity, from Qloo's Taste AI API.
  • The why behind every pick: affinity score, shared taste tags, and which similar artists' fans drove the result.
  • Co-bill ideas and merch/poster cues from cross-domain tastes such as brands and films.
  • A pitch email draft per venue (template text) that leads with the evidence. You copy it and send it yourself; GigRoute never sends email.
  • Share and export: permalink, Markdown or JSON download, print view.
  • A "Why this route" summary written by NVIDIA Nemotron: once the plan is built, Nemotron 3 Super on Nebius Token Factory rewrites the route summary in plain sentences, using only the plan's own facts. A credit line under the summary names the model, and the JSON export records "summarySource": "nebius:nvidia/nemotron-3-super-120b-a12b".

How we use NVIDIA Nemotron and Nebius Token Factory

After the Qloo tool chain finishes, lib/agent/nebius.ts collects the plan's grounded facts: the artist, the top co-bill artists, the route-ordered cities with their affinity scores, the top venues per city, the taste tags they share, and the deterministic summary. It sends them to NVIDIA Nemotron 3 Super (nvidia/nemotron-3-super-120b-a12b) through Nebius Token Factory's OpenAI-compatible /chat/completions endpoint (https://api.tokenfactory.nebius.com/v1/), using a plain fetch from a Vercel serverless route, with temperature 0.4 and up to 2000 tokens. Reasoning is switched off (reasoning_effort: "none", enable_thinking: false) because a short grounded rewrite doesn't need it. The system prompt tells the model to use only those facts and never invent venues, cities, numbers or artists.

Nemotron writes the "Why this route" summary on the plan page, and that summary is also used in the Markdown and JSON exports. The model does not choose cities or venues. Those come from Qloo data and GigRoute's own routing.

On the live site, the Nemotron step took 1.13 s (median) and 0.61-3.6 s across 12 measured calls, so it runs inline on every plan without slowing anything down.

Guard rails: the step runs only when NEBIUS_API_KEY is set (the key lives only in Vercel's environment) and has a 20-second timeout inside the route's 60-second limit. Any <think> block is stripped, and sentences that restate the prompt's rules are removed. A reply longer than 600 characters is trimmed at the last sentence end before 600 characters (or at a word boundary with an ellipsis if there is no sentence end), with a hard cap of 700 characters. A reply is rejected only if it is empty after this cleanup or contains a link or an email address. On any failure the plan keeps its deterministic summary and the credit line is left out, so a slow or failed model call never breaks a plan.

Not used: Nebius AI Cloud compute (the app is hosted on Vercel), Serverless Endpoints/Jobs, Tavily.

What was significantly updated during the Submission Period

  • GigRoute's repository was created on 24 Oct 2026, inside the Submission Period (26 Aug to 30 Oct 2026). It is not older code reused.
  • It was first built for another hackathon (Qloo Agentic Hackathon) as a Qloo-powered tour planner, and we say so openly.
  • Built 24-26 Oct: the core agent and typed Qloo client, the streaming UI and map, explainability panels, permalink and export, tests, and live-API fixes (UK crash, US region handling, wrong-country and neighbouring-town venues).
  • Added for this hackathon on 29-30 Oct (PRs #10, #11 and #12), live on master 23543d3:
    • NVIDIA Nemotron on Nebius Token Factory: the new lib/agent/nebius.ts sends the plan's grounded facts to Token Factory's /chat/completions endpoint (default model nvidia/nemotron-3-super-120b-a12b) and has it rewrite the route summary from those facts only.
    • Tuning after the first live calls (PR #11): reasoning off, max_tokens 2000, a 20 s timeout within the function's maxDuration, and logged fallback reasons.
    • Length and focus (PR #12): a tighter prompt (under 450 characters, cities in route order), long replies trimmed at a sentence boundary instead of rejected, and sentences that restate the prompt's rules stripped.
    • Safe fallback: if the key is missing, or there is an HTTP error, a timeout, a bad response or a reply that fails validation, the plan keeps the deterministic summary. Qloo calls and venue selection are unchanged.
    • Visible in the app and the exports: the plan page credits the model under the summary, JSON exports gain summarySource (nebius:<model> or deterministic), and Markdown exports use the rewritten summary.
    • Tests and docs: new Vitest tests cover the disabled, network-error, HTTP-error and success cases, plus <think> stripping and URL building. README and .env.example document the new variables.

How we built it

  • Next.js 16 App Router, React 19, TypeScript and Tailwind CSS 4, with Leaflet and OpenStreetMap for the map, deployed on Vercel.
  • Nebius Token Factory is called with a plain fetch to its OpenAI-compatible API, configured through NEBIUS_API_KEY plus optional NEBIUS_BASE_URL, NEBIUS_MODEL and NEBIUS_TIMEOUT_MS.
  • A typed Qloo client with an LRU cache and retries; Server-Sent Events stream every step to the UI.
  • A Vitest suite, including the Nemotron step tests, and a live API contract check script.
  • A deterministic mode lets the app run with no keys, so there is always a working path.

Challenges we ran into

  • Real-world geography: in the live data, "Edinburgh" resolved to Edinburgh, Indiana, so venue lookups are now pinned to the tour's country.
  • Messy live data: some tags have a type but no name, so a defensive normaliser drops them.
  • Making explainability legible to a musician: raw scores become sentences like "driven by fans of X".
  • Keeping an LLM honest and short: we give Nemotron only the plan's own facts, turn reasoning off, strip <think> blocks, and reject replies that contain links or emails. Early replies sometimes ran long or restated our instructions, and a hard length cap threw too many of them away. We now trim long replies at a sentence boundary and strip sentences that echo the prompt's rules (PR #12); after that, 12 of 12 live test plans kept Nemotron's summary.
  • Honest fallbacks: sample data is always labelled, and the credit line appears only when Nemotron actually wrote the summary.

Accomplishments that we're proud of

  • Every recommendation can be explained, down to an affinity score, the shared tags and the artists whose fans drove it.
  • Pitch drafts a booker might actually read, because they lead with evidence.
  • The AI-written summary is grounded and labelled: the UI and the export say which model wrote it, or that it is deterministic.
  • Works with no keys at all, which made it fully testable.

What we learned

  • Cross-domain taste data persuades when it is specific ("your regulars over-index on Portishead").
  • Signals from a small cluster of related artists are steadier than signals from one artist.
  • With reasoning off, Nemotron 3 Super on Token Factory answers in under a second, fast enough to run inline on every request. Length control has to be enforced in code, not just requested in the prompt, and trimming works better than rejecting.

What's next for GigRoute

  • Move the tool-calling planner itself onto Nemotron.
  • Venue-type filtering, drive-time routing with dates, and day-of-week patterns.
  • Age-band signals to choose between all-ages rooms and bars; saved tours and a booker CRM with explicit consent and no auto-sending.
  • Venue capacity data from partners, and inference on Nebius Serverless Endpoints.

Built With

Share this project:

Updates

Submission history