AIGossip — Theory Court

A courtroom for AI strategy, built from real podcast archives with VideoDB.

AIGossip turns a large AI/technology podcast archive into one focused, contested case. Instead of presenting another feed of summaries, Theory Court puts a strategic claim on trial: it shows evidence for the prosecution, evidence for the defense, and a transparent verdict that can change as the archive grows.

The current submission case asks:

Is Elon building one capital-and-compute empire?

The checked-in public snapshot was produced from 186 indexed episodes across 10 podcasts. The published case contains six manually reviewed, semantically retrieved VideoDB Shots from three shows, with exact timestamps, real similarity scores, and generated HLS playback URLs. It is not synthetic media or mocked output.

What the demo shows

Theory Court is intentionally a one-case experience:

1. The charge — a precise, falsifiable strategic theory.
2. The prosecution — evidence that AI answers threaten publisher traffic, trust, or Search economics.
3. The defense — evidence challenging the economics, governance, and valuation of the connected-company strategy.
4. The verdict — a reasoned decision, confidence level, and the evidence that could reverse it.
5. Provenance — the source show, episode, and transcript excerpt behind each exhibit.

The UI reads its real archive snapshot from public/intelligence.json. An API key is not required to run the checked-in UI.

Quick start

Requirements:

• Node.js 18 or newer
• npm

git clone https://github.com/MadanChaollaPark/aigossip.git
cd aigossip
npm ci
npm run dev

Open http://localhost:5177.

Build and preview the production bundle:

npm run build
npm run preview

dist/ is generated locally and intentionally ignored by Git.

Rebuild the archive with VideoDB

Running the pipeline is optional for viewing the submission UI. It requires Python, network access, a VideoDB account, and VideoDB compute/ingestion credits.

python3 -m venv .venv
source .venv/bin/activate
pip install -r pipeline/requirements.txt

cp .env.example .env
# Add your VideoDB API key to .env.

Start with a small archive:

python pipeline/discover_episodes.py --limit 1
python pipeline/ingest_videodb.py --workers 1

That verifies ingestion, but it does not recreate the checked-in court. The public case uses the six explicit episode IDs in ALLOWLIST_EPISODES inside extract_intelligence.py. After those assets have been ingested and spoken-word indexed:

python pipeline/extract_intelligence.py
npm run build
npm run dev

For a fresh full recreation, discover enough episodes to include that allowlist and ingest the Big Technology, Pivot, and Dwarkesh feeds. Podcast episodes are long, and ingestion/indexing can take time and consume credits.

How VideoDB is used

The implementation uses these VideoDB SDK primitives:

Stage	SDK primitive	Purpose
Connect	videodb.connect(api_key=..., base_url=...)	Opens the VideoDB connection.
Collection	conn.get_collection(...)	Selects the configured or default media collection.
Ingest	collection.upload(url=..., name=...)	Uploads real podcast audio or video from discovered public feed URLs.
Resolve media	collection.get_audio(id) / collection.get_video(id)	Reopens an uploaded asset using the correct media type.
Transcript/index	media.generate_transcript()	Produces transcripts for audio assets.
Spoken index	video.index_spoken_words()	Creates timestamped spoken-word embeddings for semantic retrieval.
Compatibility fallbacks	media.generate_transcript() / media.index_audio()	Supports assets and SDK responses that expose different indexing methods.
Retrieve transcript	media.get_transcript_text()	Pulls VideoDB-generated transcript text into the local extraction step.
Semantic retrieval	video.search(..., search_type=SearchType.semantic, index_type=IndexType.spoken_word)	Finds meaning-matched podcast moments inside an explicit, attributable video allowlist.
Search result	SearchResult.get_shots()	Returns the exact text, source video, relevance score, and start/end time.
Act / playback	Shot.generate_stream()	Turns each accepted semantic result into a playable HLS evidence clip.

The live path deliberately excludes audio-only transcript chunks and approximate locators. A public exhibit must be an exact VideoDB Shot with a playable stream_url or player_url; otherwise the build fails.

Architecture

Podcast RSS feeds
      │
      ▼
discover_episodes.py
      │  episode metadata + real media URLs
      ▼
ingest_videodb.py
      │  VideoDB upload + transcript/spoken indexing
      ▼
local ignored working data
      │  transcripts + resume state
      ▼
extract_intelligence.py
      │  per-video semantic spoken-word search
      │  exact Shot timestamps + scores
      │  human-reviewed support/challenge gate
      │  Shot.generate_stream()
      ▼
public/intelligence.json
      │
      ▼
React/Vite Theory Court UI

extract_intelligence.py searches six explicit, spoken-word-indexed VideoDB videos with natural-language queries for both sides of the case. It preserves VideoDB's real score, text, video ID, and timestamps. Only six manually reviewed Shots are allowed into the public payload, and each one must generate playback successfully.

There is intentionally no local keyword or estimated-timestamp fallback. npm run build first runs scripts/validate-intelligence.mjs, which rejects missing clips, approximate locators, duplicate Shots, incomplete provenance, and broken theory/evidence references.

Repository layout

.
├── public/
│   └── intelligence.json       # Public, derived archive snapshot used by the UI
├── src/
│   ├── App.jsx                 # Theory Court experience
│   ├── main.jsx
│   └── styles.css
├── pipeline/
│   ├── podcasts.json           # Curated source feeds
│   ├── discover_episodes.py    # RSS discovery
│   ├── ingest_videodb.py       # VideoDB ingestion and indexing
│   ├── extract_intelligence.py # Evidence/theory extraction
│   ├── requirements.txt
│   └── run_all.sh
├── scripts/
│   └── validate-intelligence.mjs # Fail-closed public-data contract
├── .env.example
├── package.json
└── vite.config.js

Generated transcripts, ingest state, logs, local environments, secrets, dependencies, and build output are excluded from the public repository.

Source archive

The configured feeds are:

• The Vergecast
• Big Technology Podcast
• Better Offline
• Decoder with Nilay Patel
• Acquired
• More or Less
• All-In Podcast
• Pivot
• Dwarkesh Podcast
• Latent Space

The feeds and episode media are owned by their respective publishers. AIGossip stores only the derived structured snapshot needed for the hackathon demo in the public repository.

Demo walkthrough

A concise walkthrough can be recorded in roughly 90–120 seconds:

1. State the problem: strategic theories are scattered across hours of podcasts.
2. Show the real archive count and VideoDB provenance.
3. Read the claim about SpaceX, xAI, and Tesla operating as a connected capital-and-compute system.
4. Play one supporting exhibit and one challenging exhibit.
5. Show the case's falsifiers—what evidence would change the conclusion.
6. Close with the pipeline: ingest → spoken-word index → semantic Shot → generated clip → Theory Court.

Limitations

• Only six allowlisted m-* video assets are searched for the public case; the larger audio archive is not used as approximate evidence.
• Semantic similarity retrieves candidates but does not prove stance. Every published Shot is therefore manually reviewed and explicitly labeled support or challenge.
• Transcript excerpts can contain recognition errors and should be understood in the context of the source episode.
• The case framing is editorial synthesis, not investment advice or a claim that every podcast agrees.
• The public snapshot is static; rebuilding it requires a VideoDB API key and compute credits.
• Generated stream URLs can expire; the payload retains videoId, start, and end so they can be regenerated.

Hackathon alignment

AIGossip follows the challenge's media-intelligence loop:

• Ingest: real archived podcast audio/video is uploaded from public feed URLs with VideoDB.
• Index: VideoDB spoken-word indexing turns long-form media into timestamped semantic embeddings.
• Retrieve: per-video semantic search returns exact, scored Shots for supporting and challenging natural-language queries.
• Act: Shot.generate_stream() makes every published exhibit playable, and the interface organizes those clips into a prosecution, defense, and falsifiable case.

This submission emphasizes a working, source-visible product over a broad slide deck. The repository includes the application, the VideoDB pipeline, reproducible setup instructions, and a real derived data snapshot.

Suggested submission copy

One-line pitch

AI Gossip puts tech theories on trial with exact podcast clips for, against, and a source-backed verdict.

Short description

AIGossip Theory Court turns a real archive of AI and technology podcasts into a focused strategic case. The submission asks whether SpaceX, xAI, and Tesla increasingly operate as one capital-and-compute system. VideoDB ingests and indexes the media, then semantic spoken-word search retrieves exact podcast Shots for supporting and challenging queries. Six manually reviewed exhibits preserve VideoDB's real source, score, and timestamps; Shot.generate_stream() makes each one playable. The interface presents both sides, the evidence that would falsify the claim, and a transparent provenance trail instead of another transcript-summary feed.

Security

• Never commit .env or a real API key.
• Use .env.example only as a template.
• Keep VideoDB credentials on the pipeline/server side; do not expose them through Vite client variables.
• Review staged files and run a secret scan before making the repository public.