LaunchLens: Launch where your audience already is

Inspiration

Launching a product is a bet on people you have never met. Small teams guess where to start. They guess who to talk to. Then they guess what the ad should say.

I asked an LLM where to launch a portable speaker. It gave a confident answer, but it could not tell me why. It had no real data about what people in those cities actually like. Qloo has that data. So I built an agent around it.

What it does

LaunchLens turns a product brief into a launch plan you can check.

• Real interests, not guesses. Each audience interest, like Taylor Swift or Bad Bunny, is resolved to a real Qloo entity. If a match is unclear, the agent pauses and asks a person.
• Hard rules first. A city outside your partner area is excluded. Taste cannot override that.
• Taste you can compare. One shared Qloo query covers every candidate city. Each city's share of results is compared with a no-taste baseline.
• Why these places? Qloo recommends venues for each audience. Its explainability shows which interest drove each venue.
• Ads with receipts. The agent writes a strategy, then English and Spanish flyers and a short video. Every line traces back to product facts. Unsupported claims are blocked.
• Clear labels. Anything a language model writes is marked as a hypothesis. It is never shown as data.
• Ask LaunchLens. A chat assistant answers questions using live Qloo data.

There are two samples. One is a US speaker launch in New York, Phoenix and Houston. The other is a power wheelchair launch in India, with Hindi and Bengali ads.

How I built it

• Agent: LangGraph runs the workflow. It goes through intake, entities, places, taste, evaluation, placements, strategy, creative and export. Checkpoints live in PostgreSQL, so a crashed run resumes where it stopped.
• Qloo: /search and /v2/tags resolve interests. /v2/insights returns places near each city, with explainability for each recommendation.
• Taste lift: for each area, I compare its share of taste results with its share of baseline results. I use light smoothing:

$$\text{lift}(a) = \frac{(n_{\text{taste}} + 0.5)\,/\,(N_{\text{taste}} + 0.5k)}{(n_{\text{base}} + 0.5)\,/\,(N_{\text{base}} + 0.5k)}$$

Each audience gets a $\log_2$ lift, and the mean across audiences becomes the cultural-fit score.

• Practical evidence: OpenStreetMap for places, Nominatim for geocoding, and Open-Meteo for climate.
• Creative: xAI Grok Imagine makes the images and video clips. Sarvam AI handles Hindi and Bengali translation and voice.
• App: FastAPI, PostgreSQL with PostGIS, and a React + TypeScript frontend with MapLibre maps.
• Safety: every paid call is reserved against a cost cap before it runs. Nothing is spent without approval.

Challenges I ran into

• Qloo silently ignores invalid parameters and returns an empty result. I had to treat "empty" as "unknown", not as zero.
• Raw affinity scores from different queries are not comparable. The shared query plus baseline fixed that.
• Public map APIs rate-limit hard. I serialized calls and added backoff and caching.
• My primary LLM ran out of credits mid-build. Automatic fallbacks kept the agent working.

Accomplishments that I'm proud of

• Every recommendation links to its evidence, including which Qloo interest drove it.
• The agent stops before spending money and waits for a person.
• The same workflow runs end to end in two countries and four languages.
• Judges can explore everything with one click, read-only, without breaking anything.

What I learned

Taste data changes the answer, not just the wording. Different audiences in the same city get different venues. I also learned that being honest about unknowns builds more trust than a confident guess.

What's next for LaunchLens

• Connect real pilot results back into the plan, so it learns what worked.
• Add more markets and languages.
• Let teams bring their own audience data alongside Qloo.

Built With

• fastapi
• ffmpeg
• langgraph
• maplibre
• open-meteo
• openstreetmap
• postgis
• postgresql
• python
• qloo
• react
• sarvam-ai
• tailwindcss
• typescript
• vite
• xai-grok