Neoflix AI

The Netflix for News powered by Agentic AI. Stop scrolling and start playing.

Comment

🌍 Neoflix — Netflix for News, Powered by Agentic AI

Stop scrolling through the news. Play it.

Live demo: https://neoflixai.vercel.app/

Type any topic — "the 2026 midterms", "COVID-19", "Antarctic ice sheet" — and our agentic deep research AI it, compiles a documentary-style timeline of real, sourced events, plays it out on an interactive 3D globe with a broadcast newsreader's voice, and even renders a video — all in your browser.

📺 About the Project

The idea

News today is feed-shaped. Infinite scroll, reverse chronology, headlines that scream but explain nothing. You read the latest article about a war — and you have no idea how it started, who the players are, or why the latest event matters. We're caught up on the what and completely lost on the so what.

Netflix solved this for fiction: instead of listing every episode, it gives you a series — a narrative arc with a hook, a spark, a turning point, and a payoff. We asked: why can't news work the same way?

So we built Neoflix: the Netflix for news, powered by agentic AI. Every story is a season — a timeline of real events in the world. Every event is an episode — with a timestamp, a place, a photograph, a voice, and a citation trail. Every source is rated — so you can see the political leaning and factual track record of each outlet behind every claim, and weigh the reporting for yourself.

News is real. The drama is real. The only thing AI does is organize it.

How it works

A topic becomes a story in three phases:

  1. Research (agentic loop). The model — NVIDIA Nemotron on Nebius AI Studio — runs a tool-use loop: it must call the Tavily web_search tool before writing anything. It probes broadly, then pins down the latest developments, and then writes. So everything is grounded with proper sources and citations instead of hallucinations.

  2. Compile (narrative). The model returns chronological events as JSON, shaped into a documentary arc — setup → spark → escalation → turning point → climax → fallout, or now for ongoing stories. Each event carries a connection chain: the model identifies the 2–3 real driving factors (a court ruling, a policy shift, a statistic) and weaves each one as its own mini-timeline before the moment it visibly shaped the main story — so every "why did that happen?" has an answer on the map.

  3. Ground (trust). Every event is anchored: a real place with accurate coordinates, 2+ real sources with publication dates, an outlet bias classification (political lean + factual rating, MBFC-style), and photos harvested from the coverage.

The result plays on an interactive 3D globe: campaign-style map animations show troops flowing, sieges encircling, missiles launching, and diseases spreading — exactly the kind of motion the sources describe, and nothing more. A documentary voice-over (ElevenLabs TTS) narrates each beat. You can pause, scrub the timeline, and ask the story — a streaming chat, Nemotron Nano on Nebius, that may only answer from the event records, citing each claim.

What inspired us

Three things collided:

  • The explainer gap. The best news product of the last decade wasn't an app — it was YouTube video essays and things like Vox's "explained" series. People don't want more news; they want context and closure for the news they already scrolled past.
  • Agentic AI finally got good enough to do genuine multi-step research — search, verify, cite — rather than one-shot hallucination. The tool-use loop, the strict JSON schema, the bias annotations: all of that is only possible now.
  • A question about trust. Could an AI tell the news more honestly than a feed does? Not by writing its own opinions — but by being relentlessly fact-first, showing the full source list with bias labels, and refusing to invent anything, even a photo. Neoflix is our answer: summaries stay factual and unopinionated on purpose; drama comes from real stakes and real consequences.

How we built it

The whole stack runs serverless-friendly on Next.js:

  • The story pipeline (src/lib/generateStory.ts) is an NDJSON stream: the model streams tool calls and JSON events, and the UI shows live progress ("researching…", "compiling events…"). The server-side research layer (webSearch.ts + graphResearch.ts) is graph-first: when the Neo4j knowledge graph is enabled, we search the articles our own scraper has already collected — enough fresh hits and Tavily is skipped entirely — and new search results are written back into the graph, so the next search for the same story is cheaper and faster.
  • Two storage backends behind one StoryStore interface: plain JSON files under src/data/stories for zero-setup, or Neo4j — the real knowledge graph: (:Story)-[:HAS_EVENT]->(:Event)-[:CITES]->(:Article)-[:PUBLISHED_BY]->(:Source), plus :ABOUT edges to trending (:Topic) nodes and their :TRENDED geo traffic.
  • An autonomous trend sync worker (src/lib/trendSync/). This is the "Netflix" part: a background loop runs a lazy pipeline — it scrapes Google Trends into the graph, classifies topics with the model (verdicts are cached on the Topic node, so a topic is only ever classified once), and links the stories that already exist. A worthy topic with no story is stocked on the dashboard untouched: the expensive agentic research runs when a reader actually opens the card, streamed live with progress steps — and a story:<query> lease lock in the graph means concurrent openers of the same trend queue behind one research run instead of double-generating. The dashboard then ranks what's live with a content-based recommender: your reader profile is a weighted vector over interests, and each story is scored by cosine similarity blended with a region match and a freshness prior:

$$\text{cosine}(\vec{u}, \vec{s}) = \frac{\vec{u} \cdot \vec{s}}{|\vec{u}| \, |\vec{s}|}$$

Results are then spaced out with Maximal Marginal Relevance so one subject can't occupy every slot:

$$\text{MMR} = \lambda \cdot \text{score}(\vec{s}) - (1-\lambda) \cdot \max_{\vec{d} \in \text{picked}} \text{cosine}(\vec{s}, \vec{d})$$

  • The video renderer. A full Remotion composition (remotion/StoryVideo.tsx + EarthScene.tsx) turns the story into an actual documentary: a three.js Earth with an atmospheric glow shader and a procedural starfield, a camera that flies between event locations, kinetic captions, and the voice-over tracks. The twist: we render in the browser with @remotion/web-renderer.

The challenges we faced

  • Hallucination is a plumbing problem, not a prompt problem. Our first stories cited beautiful URLs that didn't exist. Prompts didn't fix it. What fixed it: making the pipeline reject everything the model can't ground — image URLs must come verbatim from search results, images must decode (we fetch and verify bytes before offering them), sources must be real articles or fall back to the event's Wikipedia page. Trust in a citation is a property of the fetch, not of the LLM.
  • "Search once" is a lie. One search round-trip left dates and final outcomes uncertain; unbounded searching burned through tokens and latency. We landed on a 2-query budget in the system prompt: one broad, one for recent developments — and the model must decide when it's grounded enough to write.
  • Motion restraint. The first map animations animated everything — every speech got a marching arrow, and the globe became noise. The fix was a design contract in the prompt: only animate beats where something physical happened (a border crossing, a blockade, a storm making landfall), cap it at 2–4 events per story, never two neighbouring events of the same kind, and never invent a route.
  • Racing agents. When the trend worker and a user request both target the same story, they must not double-generate. We built lease locks in the graph (a story:<query> lock for generation, a refresh:<slug> lock for refreshes, ~10 minutes, auto-released) so concurrent agents queue instead of colliding — and the contract test suite proves it.
  • Rendering video in the browser. Getting a three.js Earth + Remotion + WebCodecs encoding to work inside a browser tab was its own project — the low-level createRoot API, custom extend(THREE) registration for R3F, deterministic frame-by-frame camera aiming, and hardware-acceleration probing with graceful fallback. Seeing the first mp4 come out of a browser tab was the single best moment of the hackathon.

What we learned

  • Grounding is a system design. Every layer — the search tool, the schema, the JSON validator, the image verifier — must default to refusing what it can't verify. "Fail closed" is the only reliable anti-hallucination strategy we found.
  • Graphs are great memory for agents. Storing research as a Neo4j graph (Articles, Sources, Topics, traffic) means the agent's next research session is incremental, not cold — and the graph doubles as the analytics layer for the dashboard.
  • The model is a compiler, not an author. Our best results came from treating the LLM as a strict translator of verified facts into a narrative format — with validators and caps everywhere — never as a free writer.

Built With

Share this project:

Updates

Submission history