WEAVE — Cultural Bridge Engine

Don't optimize for an isolated user. WEAVE leverages Qloo’s Taste AI to engineer evidence-backed cultural bridges and multi-sensory experiences for collective crowds.

Comment

Inspiration

Every college cultural fest we've attended follows the same broken pattern: the organizers poll each club separately, stitch together a playlist of disjoint acts, and hope for the best. The indie-rock crowd leaves during the classical set. The anime fans check out when the poetry slam starts. The food stalls have zero thematic connection to the stage. Millions of rupees get spent on lineups that actively alienate half the room.

We realized the core failure isn't bad taste — it's that every recommendation engine on the planet optimizes for N=1 (a single user). But culture is created collectively (N > 1). When 300 students from 6 different interest communities gather in one auditorium, you don't need a better playlist — you need a bridge architect.

When we discovered Qloo's Taste AI graph covering 250M+ entities across music, film, dining, fashion, and more, we saw something nobody else was building: the raw material to computationally discover the hidden cultural connective tissue between communities that think they have nothing in common.

What it does

WEAVE takes 2–4 distinct audience communities (e.g., "Indie Rock fans" and "Carnatic Classical enthusiasts"), queries Qloo's Taste AI graph for each, and mathematically discovers bridge candidates — entities that resonate across multiple communities simultaneously.

Six core capabilities:

  1. Cultural Bridge Engine: Cross-references Qloo affinity results across communities and scores candidates using a transparent triage formula based on coverage ratio and rank quality.

  2. Taste Ladders: Computes 3-step stepping-stone trajectories (Anchor A → Stepping Stone → Anchor B) so audiences aren't jarred by sudden genre jumps — they're gently walked across the cultural divide.

  3. 360° Synesthetic Triad: Queries Qloo across three sensory domains (Music/Artists, Visuals/Movies, Gastronomy/Brands) to generate a unified multi-sensory experience blueprint — because culture isn't just sound.

  4. Autonomous Audience Rehearsal: Converts communities into AI personas with empirical tag weights from Qloo results, simulates the entire run-of-show minute-by-minute, detects friction zones where taste disparities exceed 45%, and calculates the financial cost of cultural misallocation avoided.

  5. Real-Time Room Pulse: At live events, attendees open their phones, anonymously submit 2 cultural influences, and WEAVE dynamically clusters the room's emergent taste communities via Server-Sent Events — crowd telepathy in real time.

  6. Agentic Brief Parser & Tradeoff Repair: Organizers type natural-language prompts like "2-hour festival in Bengaluru for 300 students bridging anime gaming and indie folk with ₹30,000 budget" and the agent autonomously extracts structure, validates constraints, and repairs budget/time overruns without discarding acts.

How we built it

Zero-dependency architecture on Node.js 22. Every line of WEAVE runs on the Node.js standard library alone — node:http, node:crypto, node:fs. Zero runtime npm packages. This was a deliberate engineering decision: we wanted judges to read every line of logic without wading through framework abstractions.

Dual Qloo transport layer: We built a swappable adapter pattern supporting both the official @qloo/qloo-harness CLI and direct REST calls to https://hackathon.api.qloo.com with X-Api-Key authentication. The adapter is chosen at startup via environment variables, so we never hard-code a single transport.

Strict provenance tagging: Every entity, every tag, every plan item carries an explicit provenance label — qloo-live for verified Qloo responses, demo-fixture for offline test doubles. Judges can always tell exactly what came from Qloo and what didn't.

Server-side key isolation: The Qloo API key lives exclusively on the server. It is never bundled into the frontend HTML/JS, never logged, never included in exports, and never committed to git. The browser talks to our proxy endpoints only.

29 automated tests covering core bridge math, live API doubles, REST transport, agentic parsing, synesthesia, rehearsal simulation, and full UI integration — all passing in under 1.5 seconds.

Single-file frontend served from public/index.html — a self-contained dark-mode UI with an interactive 2D Taste Map canvas, drag-to-explore bridge visualization, and one-click printable production call sheets for backstage crews.

Challenges we ran into

Qloo's response schema discovery. The hackathon API documentation gave us the interface reference, but the actual response shapes, tag structures, and entity field availability required live experimentation. We built a dedicated smoke test script (npm run smoke) that validates every endpoint we depend on and saves normalized fixtures to .private/ so we could iterate offline without burning API quota.

Cross-community math without inventing fake metrics. It was tempting to create an "affinity score" and pretend it came from Qloo. We refused. WEAVE's bridge score is purely our own rank-based triage formula applied to real Qloo result positions — and we document exactly what it is and what it isn't. Keeping that honesty boundary clean while still producing useful results was the hardest design challenge.

Sensory domain mapping. Qloo's entity types (artists, movies, brands) don't come labeled as "sonic" or "visual" or "gastronomic." We had to design a domain-mapping layer that queries the right entity types for each sensory channel while keeping the cross-domain comparison meaningful.

Real-time SSE clustering at scale. Getting Server-Sent Events to work reliably for the Room Pulse feature — where dozens of anonymous attendees submit seeds simultaneously and the organizer console updates live — required careful connection management and heartbeat handling with zero external dependencies.

Accomplishments that we're proud of

  • Zero runtime dependencies. The entire production server is pure Node.js 22 standard library. No Express, no Socket.io, no React — just clean, auditable code.

  • 29 tests, 1.5 seconds. Every innovation — bridge scoring, taste ladders, synesthesia, rehearsal, agentic parsing, REST transport, UI integration — has automated test coverage that runs in under 2 seconds.

  • Live Qloo verification passed on first deploy. Our smoke test confirms real connectivity to https://hackathon.api.qloo.com across entity search, cross-domain insights, and tag exploration — all returning 200 OK with rich entity data including 40+ tags per result.

  • The "Cultural Waste Avoided" metric. Our rehearsal simulation doesn't just flag problems — it quantifies the financial cost of booking acts that alienate half your audience. For organizers, seeing "₹8,000 of cultural misallocation avoided" is more persuasive than any abstract score.

  • Honest provenance, everywhere. We never once pretended demo data was live Qloo data. Every entity in every view is tagged with its true source. We believe this is how agentic AI should work.

What we learned

  • Collective recommendation is a fundamentally different problem than individual recommendation. You can't just average individual preferences — you need to find the latent bridges that nobody in the room knew existed. Qloo's taste graph makes this possible because it encodes relationships humans don't consciously articulate.

  • Constraint validation matters more than generation. An AI that generates a beautiful 3-hour plan for a 2-hour event is worse than useless. Deterministic validation (budget ceilings, duration limits, exclusion lists) layered on top of creative generation is what makes agentic tools trustworthy.

  • Zero-dependency engineering forces clarity. Without frameworks to hide behind, every routing decision, every serialization choice, every security boundary is visible and intentional. It slowed us down initially but made debugging and auditing dramatically faster.

  • Multi-sensory design is underexplored. The moment we started querying Qloo for movies and brands alongside artists for the same community seeds, the results became dramatically more interesting. Culture is not a single-domain phenomenon, and taste graphs shouldn't be queried in isolation.

What's next for WEAVE — Cultural Bridge Engine

  • Multi-language support and regional taste graphs: Expanding beyond English-language cultural references to serve organizers in India, Southeast Asia, Latin America, and Africa where festival culture is massive but underserved by existing tools.

  • Live Qloo-powered Room Pulse at real events: Partnering with campus festival organizers to deploy the Room Pulse feature at actual events with 500+ attendees, measuring real-time taste clustering accuracy against post-event surveys.

  • Deeper domain expansion: Adding Qloo's dining, podcast, book, and travel entity types to create richer 5-domain sensory blueprints covering the entire attendee experience from stage to food court to merch booth.

  • Collaborative organizer workspaces: Multi-user editing where different committee heads (music, food, decor, sponsors) work on the same WEAVE brief simultaneously and see how their changes affect the collective bridge map.

  • Production-grade deployment with persistent state: Moving from in-memory analysis storage to a lightweight persistent layer so plans survive server restarts and can be revisited weeks later during post-event retrospectives.

Built With

Share this project:

Updates

Submission history