Fangorn.tv

Inspiration

In 2020, NBC's Peacock officially launched and pulled the license for "The Office" from Netflix. I was bothered; another gatekeeper forcing yet another SaaS subscription to consume a single series could not be justified.

Growing up with services like Limewire, this felt like a massive degradation in user experience. While the technology for distributing media has become more powerful, the consumer experience seems to be converging to the worst parts of cable TV again: fragmented catalogs behind increasingly costly paywalls, centralized recommendation systems, the reintroduction of advertisements, and increasingly little control over what you consume and how you discover it.

This led to a multi-year journey into the depths of cryptography, storage, search, discovery, payment, privacy, and the many failed iterations of a sovereign, semantic web, in an effort to understand the economic and social factors that arise to bring us "Streaming services that are just TV again". Fangorn TV is an experiment of what it might look like if media curation, synthesis, and recommendation were designed for both humans and agents from the beginning.

What it does

Fangorn.TV is an agentic media platform that lives in the browser. It is a static site that exposes its own semantic dataset to agents through WebMCP. The key idea is that the site itself is the agent's data source, that the semantic index and media operations are exposed directly to an agent with WebMCP. Seeded from a slice of the Internet Archive, it holds ~20k titles to choose from. It has no ads, no login, and collects no user data whatsoever.

For a human (without an agent), it lets you "own your algorithm":

Maintain Client Privacy: privately search the archive by semantic meaning (e.g. "cats") entirely in the browser. Queries never get broadcast to a third party, your behavioral data remains yours.
treat the internet archive as live TV channels that can be synced across viewers (i.e. watch with your friends), even building your own custom channels based on meaning
Since all data in Fangorn.TV is a vector embedding, users can use ("train") a Markov kernel (over the embedding space) built on their actual behavior, providing newer ways to 'be your own discovery algorithm'

Using WebMCP tools and an autonomous agent (like Claude Code):

Agentic Media Curation: An agent can control playback based on your actual intent and preference, further amplifying the "own your own algorithm" capabilities. An LLM can be prompted to "Find that one episode of XYZ where THINGS happens", or "Create a new channel that only has shows and movies about dogs" and watch as it produces Dog TV in the browser.
Byte-Level Range Requests: Agents can efficiently discover granularly labeled content and extract exact video slices directly using HTTP Range headers instead of downloading gigabytes of raw source files (e.g. efficient GIF extraction from media playing in the browser).
Programmatic Media Synthesis: Allows an agent to efficiently synthesize disparate archival footage, builds seamless audio beds, applies dynamic text overlays, and executes frame-accurate FFmpeg cuts to produce polished short documentaries, GIFs, and audio clips.
Zero DOM Scraping: Eliminates fragile HTML parsing, selector guessing, and simulated UI clicks. The agent interacts purely through typed, deterministic tool interfaces.
Zero-Telemetry Local Discovery: Queries are resolved instantly against client-side vector bundles. The agent receives exact media segment URLs, transcript timestamps, and metadata in milliseconds—running search entirely on the client without exposing behavioral data to external backends.

Beyond these immediate capabilities, Fangorn.TV does something less noticeable. It presents a reusable pattern for deploying static sites that simultaneously act as rich, agent-ready datasets with incredibly low overhead both in terms of storage, cost, and bandwidth. The same pattern can be applied to nearly any dataset.

How we built it

Fangorn.TV existed before we entered the hackathon, but without WebMCP integration. The majority of work during this hackathon involved both WebMCP integration and associated agentic tooling and testing.

The application is built using the Fangorn SDK, a "git for knowledge graphs" protocol anchored to Arbitrum and backed by IPFS. We crawled the Internet Archive's Video and TV catalog, cross-referencing entries with wikidata and attempting to filter out content that either lewd/illicit/obscene, deemed low quality, or non-CC0/PD. We used the metadata to build a knowledge graph, organizing content hierarchically (e.g. title > series) and committing it onchain using Fangorn.

Then, we run a multimodal feature extraction pipeline (developed during the hackathon in order to enhance the semantic richness of the embeddings), extracting timestamped subtitles using whisper and summarized video features using granite. This enriched data is then used to extend the KG that was committed to previously, adding new vertices and edges to map media to its extracted features. With the time available, we were able to execute this on roughly ~250 videos (using an RTX 3050/i9 - estimates indicate ~21 days for the entire catalog).

The graph committed in Fangorn is then used to build vector embeddings (using Qdrant), where we leverage int8 scalar quantization to minimize the memory impact of the set of embeddings, make it small enough to efficiently live within a statically hosted Vite site. This site is deployed as a page on cloudflare, https://tv.fangorn.network, where WebMCP integration makes the bundled embeddings easily queryable by an agent.

Challenges we ran into

Restricting to Open/Public Domain Content: Navigating copyright boundaries requires strict filtering for CC0 and public domain assets. While we made a best effort to limit this, some content still made it through our filters.

- Rich Semantic Embeddings Under Constraints: As mentioned above, our pipeline first extracts subtitles and video features, then builds a graph, and then on top of this embeddings. Due to computational and temporal constraints, we have only produced rich embeddings (i.e. including subtitles + features) on roughly 1.5% of the available catalog (so far).

Accomplishments that we're proud of

Autonomous Documentary: We used WebMCP to generate multiple 'documentaries' composed full of real archival footage.
Zero telemetry RAG: Achieved fully private, semantic vector search running 100% inside the user's browser runtime through WebMCP.
Massive bandwidth reduction: reduced data transfer by over 90% using HTTP range requests instead of pulling raw video files into an editor.

What we learned

Static sites can act as agentic backends: Instead of running a bespoke MCP server in order to make these embeddings available, we only need a static page deployed (e.g. on cloudflare), incurring virtually zero cost. By shipping quantized embeddings (built on top of a structured KG) and WebMCP, it becomes possible to turn a static webpage into a rich database that agents can natively query and leverage. The operational cost collapses to near zero.
Efficient web tools can be used to optimize agentic compute: By using HTTP range requests and fine-grained timestamping (on the vids with enriched feature extraction), agents don't need local copies of massive datasets, instead benefiting from byte-level retrieval.
A missing consumer class emerges: The Semantic Web of the early 2000s failed because there were no entities that needed to navigate RDF graphs. AI agents are the missing consumer that makes structured semantic data viable and necessary.

What's next for Fangorn.tv

While we used video streaming here, Fangorn TV is only a media-focused proof-of-concept for a broader architectural paradigm. The underlying pattern, where we leverage version controlled graphs, quantized vector embeddings, and client-side WebMCP interfaces, generalized to any dataset or web application. It fundamentally redefines how static web pages can host and serve data for both humans and agents.

Generalizing Beyond Video

By making the architecture reusable, we can allow developers to ship static, zero-latency, privacy preserving, agent-native applications across nearly any domain. For example:

Private E-Commerce: Users and their agents can search and purchase items (using x402f - our x402-based private paymaster scheme using Semaphore) without sending query intent, browsing history, or shopping telemtry to centralized trackers.
Documentation and Research: Static libraries, like docs, research catalogs, and corporate knowledge bases can instantly become queryable by LLMs. For example, we previously stood up experiments like the surgext manual to demonstrate search capabilities. The same approach could be useful for government laws, logs, and meeting notes, as evidenced by the official Piedmont, Alabama webpage, whose agenda and minutes are backed by Fangorn.

Protocol Roadmap & Feature Expansion

Apart from generalizations, Fangorn TV's potential can be enhanced with addition features:

Two-Sided Publisher Ecosystem: We are collaborating with early media partners to complete the publishing pipeline. Building on the team's existing work with privacy-preserving x402-based stablecoin payments, content creators can index, publish, and monetize datasets trustlessly.
Client-side wasm vector indexing: Integration wasm vector search engines, like voy to enable fast search on massive graphs.
OpenTimelineIO (OTIO) Export Pipelines: The WebMCP is already capable of exporting as OTIO, but this is untested. Properly tested and expanded, this allows an editor to easily fine-tune AI-composed cuts inside software like Premiere or Davinci Resolve, where it can easily augment traditional video editing workflows.
Live Embeddings and Dynamic Delivery: The current build leverages a static set of embeddings baked into the dist. The team has already prototyped infrastructure for watching graphs committed to Fangorn ("subscribing" to them), building live embeddings, and delivering diffs to the frontend. Given additional cloud compute resources and testing, this layer and transform the 'static' set of embeddings into a live, publisher-driven set.