diff --git a/daily/2026-06-02-youtube.md b/daily/2026-06-02-youtube.md
new file mode 100644
index 0000000..35b25fb
--- /dev/null
+++ b/daily/2026-06-02-youtube.md
@@ -0,0 +1,155 @@
+# YouTube Digest — 2026-06-02
+
+14 new videos across 40 channels. 6 worth full watch, 8 skim-only, 0 skipped.
+
+_All videos in this digest are marked `(transcript unavailable — summary based on title + description only)`. The transcript API returned `IpBlocked` and the yt-dlp fallback failed with `SSL: CERTIFICATE_VERIFY_FAILED` on the environment's egress proxy. Summaries lean on publisher-provided descriptions and chapter markers (which were unusually rich for the AI Engineer talks today). Durations marked `~` are estimated from the last chapter timestamp; `?` where no chapters were published._
+
+## Watch Fully (6)
+
+### [20 days of compute vs 7 hours: rethinking what state-of-the-art means — Bertrand Charpentier, Pruna](https://www.youtube.com/watch?v=hqHC6Z_lXyo) — AI Engineer (?min, category: ai-agents)
+**TL;DR:** Pruna's chief scientist reframes "state of the art" as a Pareto front between quality and efficiency — and shows the headline model is the wrong choice for ~40% of real use cases. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- The cost-of-eval number is the rhetorical hook: running Design Arena's protocol (26k battles, 62s/generation) on uncompressed image models costs $5k and 20 days of compute; the same eval on a compressed model takes 7 hours and $265. For Ara's agent evals, this is permission to compress aggressively before running expensive comparative harnesses — the ranking is roughly preserved while the cost collapses by ~75x.
+- Leaderboards disagree with each other — same model can be rank 10 on one and rank 5 on another — so a single global ordering is the wrong abstraction. The replacement is *Pareto front by axis you actually care about* (quality vs latency, quality vs cost). Justin's Ara router should pick models by Pareto position for the live constraints of each task, not by "best on Arena."
+- Most models lose ~40% of their head-to-head battles. Translated: the top-ranked model is wrong for nearly half of prompts. This is a quantified case for Justin's Familiars/Ara to keep multi-model routing as a first-class feature rather than collapsing to "just call Opus."
+- The frontier in practice clusters 3-4 models within a tight quality band but spreads up to 20x in efficiency — and the cluster often contains small specialized models, not the headline foundation model. Direct implication: for Nebula Nodes' image/design pipeline, the competitive move is curating small specialist models on a Pareto front, not chasing FLORA's flagship.
+
+**Tools mentioned:** Pruna AI, Design Arena, model compression / quantization
+
+**For /bookmark:** `https://www.youtube.com/watch?v=hqHC6Z_lXyo`
+
+---
+
+### [What if the network was the sandbox? — Remy Guercio, Tailscale](https://www.youtube.com/watch?v=BM2JX9hqsVQ) — AI Engineer (?min, category: ai-agents)
+**TL;DR:** Tailscale's Aperture moves credentials out of the agent runtime entirely — the agent holds a placeholder; the network injects the real key at the WireGuard layer. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- The reframe is the takeaway: standard sandboxing conflates *execution isolation* (where can the code run?) with *access control* (what credentials does it carry?). You can perfectly isolate a runtime and still have the agent holding an API key it can exfiltrate. Separate the two and you solve a problem that sandboxing alone never can. This is directly applicable to how Ara handles per-user / per-tool credentials.
+- Aperture's architecture: every connection in the Tailscale network carries verified identity (user, tag, group); the agent calls a stable placeholder URL, the gateway swaps in the real key, the upstream sees a real auth header but the agent never did. "Nothing to exfiltrate" is a stronger property than "exfiltration is monitored."
+- Because all LLM and tool traffic *must* go through the network gateway, observability comes for free — every tool call, MCP request, and bash invocation is visible without instrumenting the container. The internal data point: bash dominates over structured tool calls inside Tailscale's own agents, which they only learned because of this vantage point. Worth checking Ara's actual call mix against the same prior.
+- Pattern is portable even without Tailscale: any auth-injecting proxy + identity-bound network gives you (a) credential hygiene by construction and (b) a single point to observe the entire agent surface. If Ara grows beyond a single user/tenant, this is the architecture to plan toward.
+
+**Tools mentioned:** Tailscale Aperture (LLM gateway), WireGuard, MCP
+
+**For /bookmark:** `https://www.youtube.com/watch?v=BM2JX9hqsVQ`
+
+---
+
+### [How to talk to statues — Joe Reeve, ElevenLabs](https://www.youtube.com/watch?v=u-rJwPPU3QA) — AI Engineer (?min, category: ai-agents)
+**TL;DR:** A two-hour Sunday vibe-coded multimodal voice app — phone + OpenAI deep research + ElevenLabs voice design — went to 1.5M impressions and inbound from museums, auction houses, and travel platforms. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- The pipeline is the pattern to steal: camera frame → deep-research call (identifies the object, generates historical context + a voice persona description) → voice-design API (synthesizes a matching voice from that description) → agent spins up → real-time conversation. ~30 seconds end-to-end. Three composable APIs and a single one-shot prompt did the entire build. Concrete template for Familiars' "give any object/character a voice" loop.
+- The voice-design step is the non-obvious part. Instead of picking a voice from a library, deep-research *describes* the voice (age, accent, prosody) and the voice-design API generates it on the fly. Result: each statue/character sounds distinct without anyone hand-picking voices. This is the same trick Justin should consider for any Familiars character spawned dynamically.
+- Distribution lessons: original post hit 50k impressions; reposting under a "vibe coding" framing hit 1.5M. The wrapper narrative (how it was built, in how long) outperformed the artifact itself. For demos of Ara/Familiars, frame the build process, not just the output.
+- Inbound was multi-vertical (museums, auction houses, travel) — the underlying primitive ("point a camera at a thing, talk to its agent") generalizes well. There's a small SaaS product hiding inside this two-hour build, which is itself a signal about where ElevenAgents + deep research can be productized fast.
+
+**Tools mentioned:** ElevenLabs Agents (ElevenAgents), ElevenLabs voice design API, OpenAI deep research, Cursor
+
+**For /bookmark:** `https://www.youtube.com/watch?v=u-rJwPPU3QA`
+
+---
+
+### [Hermes Agentic OS is Insane... just watch](https://www.youtube.com/watch?v=zqUdtL5l9yM) — Jack (~19min, category: indie-startup)
+**TL;DR:** A walkthrough of a self-built "agentic OS" using Hermes + Claude + AntiGravity with a memory stack, persona system, dashboard, and an overnight "dreaming" function that surfaces insights between sessions. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- Most actionable concept is the **"dreaming function"** (chapter 1:51): between active sessions, agents run reflection/synthesis passes on accumulated memory and surface what they wouldn't find in-session. For Ara, this is a serious pattern — schedule a between-turn reflection job that produces "things you didn't ask but should care about." Different shape than the inline-thinking pattern; closer to background workers writing into shared memory.
+- The **context-isolation problem** (1:05) gets explicit treatment — splitting work into personas that don't share full context, then synthesizing through a coordinator. Cost-conscious version of the multi-agent pattern. The "Personas and Cost Breakdown" chapter (3:01) is the one to actually skip to.
+- **Memory stack overview** (7:50) and **"Install Code Graph First"** (10:51) suggest the architecture uses a code-graph index as the foundational memory substrate before any agents run. Worth checking which Code Graph tool — likely a structured AST/embedding hybrid. Pattern is reusable for any agent system that needs to reason over a codebase that doesn't fit in context.
+- Treat this as concept stealing, not platform adoption — the package itself is gated behind a Skool community paywall ("price goes up June 13th") and there's clearly a marketing layer around it. The shape of the system is what's worth absorbing; you can rebuild it on Claude Skills + a vector store + a cron without paying.
+
+**Tools mentioned:** Hermes (Nous Research), Claude, ChatGPT, AntiGravity (Google), GitHub, Code Graph
+
+**For /bookmark:** `https://www.youtube.com/watch?v=zqUdtL5l9yM`
+
+---
+
+### [My App Keeps LOSING Users (And How I Fixed It)](https://www.youtube.com/watch?v=oNRrjbKiF04) — ra roque (~16min, category: 3d-graphics)
+**TL;DR:** Five-month update on Amy (productivity app) — Chris walks through a miscalculated retention metric, what week-1 retention actually was, the barcode-scanning rebuild, and the bigger retention fixes he shipped. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- Honest "I miscalculated retention last month" segment (1:17) is the most valuable bit — most indie devs cite week-1 retention without controlling for cohort definition or active-day thresholds. Watch this to calibrate how Justin should be measuring retention on Familiars/Ara: which day is "day 0," is a passive open counted, do you exclude same-day churn? The exact pitfall to avoid.
+- Barcode scanning rebuild (2:02-8:00) is a long segment for what sounds like a feature ship, suggesting it was a real engineering slog on AVFoundation / VisionKit. Likely useful reference if Familiars or any iOS Ara surface ever needs camera-based capture — file the chapter for later.
+- "Bigger retention fixes" (14:06) is the headline section to skim first. ra roque has been transparent about revenue/profit on prior episodes, so this is operator-level data, not theory.
+- Side-mention of **Wispr Flow** (8:00-9:11) — a dictation tool worth a 60-second look for Justin's own workflow. He's been pushing voice/dictation more lately; this is the indie favorite right now.
+
+**Tools mentioned:** Wispr Flow (dictation), AVFoundation / VisionKit (implied for barcode), RevenueCat (likely, given retention metrics)
+
+**For /bookmark:** `https://www.youtube.com/watch?v=oNRrjbKiF04`
+
+---
+
+### [Vibe code conversational agents in AI Studio](https://www.youtube.com/watch?v=KiJcZlqJKuE) — Google Developers (?min, category: platform)
+**TL;DR:** Google AI Studio now lets you describe a real-time conversational agent in natural language (including by voice), iterate, then publish it to a public URL. _(transcript unavailable — summary based on title + description only)_
+
+**Key insights:**
+- The ship is the "describe → iterate → publish" loop being end-to-end inside AI Studio, with voice-spec as a first-class input. This is the same primitive ElevenLabs is shipping for voice agents and that Justin is presumably building somewhere in Ara. Google's price/distribution makes it the default for non-technical users — worth watching the demo flow specifically to see how the spec-to-running-agent gap is closed.
+- Public-URL publishing is the part that competes directly with hosted-agent platforms. If publishing is genuinely one-click, the moat for any "vibe code your agent" tool shrinks to: model quality, tool/MCP ecosystem, observability, and brand. Useful framing for what Ara's wedge actually is against AI Studio (likely: deeper agentic loops + Anthropic model + better dev surface).
+- Watch for **what's *not* shown**: how do you bring your own tools / MCP servers, how do you read traces, how do you A/B prompt versions, how do you handle auth on the published URL. Those are the seams where a serious agent product still beats the platform demo.
+- Presenter is Thor Schaeff — historically a Supabase DX person, now at Google DevRel. Worth noting: Google is hiring DX talent specifically for AI Studio polish, which signals investment level.
+
+**Tools mentioned:** Google AI Studio, Gemini, voice-first prompt entry
+
+**For /bookmark:** `https://www.youtube.com/watch?v=KiJcZlqJKuE`
+
+---
+
+## Skim Summary (8)
+
+### [Cosmos 3 - NVIDIA's World Foundation Model](https://www.youtube.com/watch?v=2zDtIWeyqYs) — Sam Witteveen (~7min)
+NVIDIA shipped Cosmos 3, an omnimodal "world foundation model" for physical AI — five input modalities and five output modalities (per the technical report). Sam walks the architecture (00:19), the model lineup (02:40), the paper (04:12), and a Cosmos 3 Nano demo (05:53). Positioned as the substrate for robotics / sim-to-real reasoning rather than for agentic SaaS workflows; the open HF collection is the easy on-ramp if anyone wants to poke at it. Relevant to Justin only if Frontier Colony ever needs a physics-aware world model for sim — otherwise it's competitive AI news for the file. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** File Cosmos 3 under "physical AI infra" — not actionable for Ara/Familiars/Nebula Nodes today, but the omnimodal-in/omnimodal-out framing is where the foundation-model class is converging.
+
+---
+
+### [SWEbench is done.](https://www.youtube.com/shorts/l2r3aWn96K8) — Matthew Berman (<1min)
+Provocative Short — Berman calling SWE-bench saturated/over. No description body to anchor specifics. Likely riffing on the recent run of frontier models hitting >70% on SWE-bench Verified and the consensus that the benchmark no longer discriminates between top systems. Consistent with this week's recurring theme (Pruna talk above, prior days' AI Engineer harness skepticism): coding-agent eval has moved past SWE-bench and the field hasn't agreed on the replacement yet. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Treat SWE-bench numbers as a floor, not a ranking signal; for Ara, invest in workflow-specific evals rather than chasing public-benchmark deltas.
+
+---
+
+### [The Boring Truth About Winning](https://www.youtube.com/shorts/t5eYuE_u6w4) — David Ondrej (<1min)
+Short with no description. Title pattern matches Ondrej's usual motivational/AI-hustle Shorts — generic "consistency beats talent" framing rather than technical content. Listed for completeness; not action-driving but listing keeps the user's override path open. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Skip in practice; no specific tooling or pattern to extract.
+
+---
+
+### [This founder built a $30K MRR app in 2 weeks using no traditional coding](https://www.youtube.com/shorts/abrxh1ZY9Hg) — Starter Story (<1min)
+College student Cedric shipped PepAI (a peptide tracker) in 2 weeks using Claude + Replit + Firebase. Seven weeks post-launch: $50K total revenue, $11K MRR. Narrow vertical (biohacking / peptide users) + recurring tracking utility + AI-assisted build = the now-standard indie playbook. Stack choice (Replit + Firebase) is the lowest-friction modern Vercel-alternative for solo builders. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Validation that single-purpose tracker apps in committed-hobbyist verticals are still the easiest path to early MRR — relevant if Justin ever wants a side-project revenue stream alongside the portfolio bets.
+
+---
+
+### [Did AI just solve math?](https://www.youtube.com/shorts/9q1321vbpMQ) — Jack (<1min)
+Short, no description. Title is almost certainly riffing on a recent IMO/math-benchmark result (Jack's longer videos this week leaned heavily on news-cycle AI hype). No specific paper or model named, so the takeaway is to check whatever math-benchmark news ran in the prior 24-48h. Default Short → SKIM per the bucketing rule. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Cross-reference with /Anthropic and AI Explained feeds for the underlying result rather than relying on this Short.
+
+---
+
+### [I hate that this is true](https://www.youtube.com/watch?v=rTMRlqT8Q8c) — Theo - t3.gg (?min)
+Theo reacting to Sean Goedecke's post "AI makes weak engineers less harmful." The thesis: weaker engineers, paired with capable AI coding assistants, ship measurably fewer footguns because the AI steers them away from common anti-patterns. Goedecke's framing is provocative because it inverts the usual "AI helps strong engineers most" narrative. Theo's contrarian/web-dev audience makes this a useful sanity check on how the broader frontend community is metabolizing AI tooling — relevant for understanding the *user* of Familiars/Ara tools, not the architecture. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Read Goedecke's original post (linked in description) rather than the reaction — it's the primary source and saves the 15min.
+
+---
+
+### [Research your app idea before you build it! #shorts](https://www.youtube.com/shorts/nE5ve-R51a4) — Paul Hudson - Hacking with Swift (<1min)
+60-second pitch for **Kickstart** (kickstart.tools) — checks keyword difficulty and entry barrier for App Store ideas before you commit a week to building. Useful one-shot utility for any iOS side-project triage. Hudson's endorsement carries weight in the Swift indie scene; worth a single check the next time Justin sketches an iOS-side idea for Familiars or a Nebula spinout. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** Bookmark `kickstart.tools` as the App Store ASO/keyword sanity-check tool — one minute of input, prevents a week of wrong build.
+
+---
+
+### [Which Typescript user will result in an error?](https://www.youtube.com/shorts/en99gM81fqs) — Google Developers (<1min)
+TypeScript Short by Marily Nika on exhaustiveness checking — define a union, handle the current variants, ship; later a new variant is added and a function silently returns `undefined` because the switch lacks a `never`-typed default. Standard `assertNever` pattern. Listed for the visual of the failure case more than the lesson, which is well-known. _(transcript unavailable — summary based on title + description only)_
+
+**Takeaway:** If Ara's TypeScript surfaces have any discriminated unions for tool-call shapes or message types, audit for `assertNever` defaults — same bug class will silently bite when a new tool variant ships.
+
+---