Youtube

Tara Seshan — OpenAI’s product lead for Codex and ChatGPT Work, ex-Stripe, Thiel Fellow — maps the next era of AI on Lenny’s Podcast. Her thesis, stated in the first minute: after chat and coding agents comes the era of persistent coworkers you steer like teammates. ~82 minutes. The three eras Chat → coding agents → persistent AI coworkers The “overhang”: the gap between what AI can do and what we’re actually doing with it Steering, not rowing Agents do the rowing; your job is steering — the opinionated calls that stay human Steering climbs the abstraction ladder, but someone still owns the direction Multiplayer: steering agents alongside your teammates, not one-on-one Ambition is the new differentiator The easy stuff is trivial now, so what separates you is how ambitious you can be The best users expand what they’re capable of — they don’t just automate “Build for 2–3 months out”: building for today or for a year out are equally wrong One product, three modes ChatGPT, Codex, and Work collapse toward “you type the task, it picks the harness” Work mode is Codex under the hood, minus the coding UI Done beats perfect: ship the transformative thing, then iterate on the signal Writing as thinking vs. reporting Automate the reporting, never the thinking “Start myself, end myself” — AI goes in the middle, not the first draft Knowledge work ≠ coding Code verifies itself with tests; knowledge work has to show its reasoning The product frontier: make the model a collaborator that shows its proof of work “You fail if you build for where the models are now. You fail if you build for where you think the models will be in a year. Both outcomes are equally wrong. The only way to build is 2 to 3 months.” — Tara Seshan ...

Janet A. Carr’s first-ever sponsored stream (partnered with Render) is a 6:53:57 build-in-public marathon: she and “a friendly clanker” (Claude Code) build an AI auto-clipper that turns a VOD into topic-matched clips, and against all live-stream odds the thing works and gets deployed to Render before the stream ends. The description teases “45 minutes of clip farming and time wasting to give haters some ammo before actually getting into the coding.” ...

The Next New Thing’s weekly roundup of the 10 hottest GitHub repos. This week’s crop leans AI-heavy (a security-scanned Claude plugin registry, OpenAI Codex going open source, Apache incubating its own agent workspace) with a few pure-software gems (an open-source Logitech driver replacement, DHH’s Mac-seamless Linux, a self-hosted net-worth tracker). The picks: Claude Plugins community repo — 2,282 Anthropic-approved plugins, security-scanned, and formatted machine-readable so Claude can search it directly instead of scrolling the website. The hosts’ caveat: plugins run real code on your machine — vet them like Mac apps. GPT Image 2 prompt library — a searchable gallery of image prompts with their outputs; copy one and edit the sections you want different instead of writing prompts from scratch. Omari (DHH) — “Linux that’s as seamless as a Mac,” aimed at reviving old machines macOS no longer supports; $10M raised, Touch ID support in the works. OpenLogi — open-source replacement for Logitech’s bloated driver software: no login, no birthday questions, no telemetry phoning home. OpenAI Codex is open source — the CLI is free, editable, and redistributable: swap in cheaper models, rewrite the prompts, or fork it into your own tool. (Claude Code, by contrast, is closed.) Apache AI agent workspace (incubating) — a foundation-backed agent runtime with an append-only log of every model call, tool call, and permission. The durability bet: “I wouldn’t build a business on vibecoded agent tools; I would on Apache.” Mojo — Python-like syntax with C/C++ performance, aimed at the AI-era workload of LLM-generated code. Money Printer Turbo — open-source CapCut: all-AI or AI-composited video from existing footage and audio, all the knobs, no upsell. 34 free AI tiers stack — a rotation of free API tiers to hop between when you burn through one; $19/yr for the maintained list. TOS-gray, but handy for agent experimentation. Securo — self-hosted net-worth tracking wired to 2,000+ banks via SimpleFIN ($1.50/mo); the local, no-upsell alternative to the Personal Capital/QuickBooks path.

Peter Yang compares ChatGPT, Claude, Grok, and Gemini head-to-head with live demos across 10 use cases (August 2026). ~27 minutes. The winners by category Design → Claude — Claude Design asks clarifying questions first (none of the others do) and Fable 5 produces real product-launch videos via the free Hyper Frames skill; Grok’s app prototypes were the most visually impressive (layout + image gen), Gemini had alignment issues; watch out for the “Claude beige” default look Everyday answers / personality → ChatGPT — Claude’s personality peaked at Opus 4.6; Opus 5 is judgmental and full of Claude-speak; ChatGPT dropped its “if you want, I can also…” quirk Writing / editing → ChatGPT — Claude’s writing “devolved” into Claudisms (“this is X not Y”); ChatGPT sticks to his style with a newsletter skill + the no-AI-slop skill (5,000+ GitHub stars) Planning → Claude Fable — still “the smartest and wisest model in the market”; it caught “close the video ops gap this week” that ChatGPT missed Coding → ChatGPT — browser use and long-running conversations; caveat: his L8-engineer friend Kun says GPT-4-so and Opus over-engineer, and prefers Grok for surgical changes (“not 500,000-line changes”) Browser / computer use → ChatGPT — an OpenAI employee prepped a whole immigration package (7 years of taxes, bank statements) in minutes; forms, government sites, even corporate training videos Voice chat → ChatGPT by far — a live voice thread that orchestrates other threads and agents Image gen → ChatGPT — followed his brand guidelines for infographics; Gemini’s Nano Banana is comparable with the right prompt Video gen → Gemini — crazy Japanese commercials; Grok’s version was “pretty damn scary”; Chinese tools like SeaArt have no restrictions Personal agents → ChatGPT — the harness race is less about the model than the tool; Grok Bot has the cleanest UX but is too restrictive (one thread per agent); Gemini’s Spark is interesting but short on plugins Overall ChatGPT is the clear winner — $20/mo gets you most of it; Claude for design and planning, Gemini for video, Grok as the up-and-coming agent contender Custom-instruction tip: “be candid, tell me what I need to hear, active voice, no AI slop words (delve, foster, leverage…)” “Whoever wins the personal agent race will capture the lion’s share of consumer attention of AI” “The personal agent race is actually less about the model and more about the harness or the tool.” ...

Github Awesome’s weekly scan of the GitHub trending board — episode #46, 35 projects (14:54). Full text version at githubawesome.com/github-trending-weekly-46/. The week skews agent infrastructure and local-first tooling. Grouped by theme: Data & databases latticedb — embedded graph database in a single file, written in Zig with zero dependencies: relationship traversal, vector similarity, and full-text ranking in one query language over the same data. A RAG query can hop from embedding → document → author in one statement instead of gluing three systems together. selfdb — a program that IS a SQLite database instead of an ELF file; the interpreter rebuilds/maps the data at launch, and SQL can inspect dependencies or update embedded content. Experimental, NixOS-heavy format — by fzakaria, whose “your executable is a SQLite database” essay is already in the /software/ feed. kern — starts a real OCI container in ~3.5ms from a 1.52MB static binary: rootless, no daemon, nothing running at rest, whole Rust dependency tree is libc. Agent tooling & memory Gradient — trains research agents with reinforcement learning (GRPO): the agent searches a synthetic company workspace, cites evidence, records every tool call, and gets scored on correctness, citation quality, and efficiency. proliferate — runs Claude Code through its own native harnesses: each task gets its own git work tree, agents delegate to subagents, and MCPs/skills/custom tools are configured once and shared. factory (addyosmani) — installs a repeatable delivery loop into a GitHub repo: issues become the cue, fresh Claude Code/Codex sessions triage bounded work, run project gates, and hand the diff to an independent verifier before a draft PR. Humans own every merge. ownmem — coding-agent memory as reviewed markdown inside the repo: Claude Code/Codex/Cursor/Grok recall the same decisions, ranked by a deterministic BM25F index — no model call, no network. backpass — improves your agents.md from its own mistakes: finds repeated failures across session transcripts, proposes small instruction changes with quoted evidence (rules need proof from 2+ sessions; nothing writes until you approve). agenttrail — shows what a coding agent is doing NOW: watches plans, tool calls, and file changes, mapped onto repo components with working/blocked/completed states. Claude Code gets rich run cards via hooks; other agents work via file watching. FrontierAgent — packages long-running research and file work into a terminal agent you can inspect: one stateful worker, a coordinator with a live taskboard, read-only inputs, diffs for every write, resumable/revertible sessions. rome — the bet that the environment matters more than the model: the unit isn’t a chat but an app — manifest + typed actions, app-owned agents, skills, hooks, a web UI, and its own database that survives the conversation. Describe something missing and it scaffolds it in as ordinary git-tracked source. sentio — gives every AI agent a real mailbox (structured authenticated events, replies in-thread) without stitching IMAP/SMTP/webhooks yourself; multi-tenant out of the box. halofy — one governance boundary between company knowledge and the agents using it: credentials resolve identity/role/namespace server-side so agents can’t claim broader access in an MCP request; reads/writes carry provenance, deletion emits a signed eraser certificate. spec-ptc — speculative programmatic tool calling: launches the slow sub-LLM calls inside generated code as futures WHILE the code streams, instead of after the harness finishes running it. doop — multiplayer design canvas where humans and AI agents edit the same work live: sandboxed iframes, cursor/comment streaming, built-in MCP server, self-hostable. Desktop & developer experience buzz — self-hosted team workspace where humans and AI agents join the same rooms with separate identities and audit trails; messages, approvals, and git activity become signed Nostr events in one searchable log. walgit — a git server in one binary backed by S3 or GCS, no database or elected leader: the bucket IS the repository, each server’s disk is just a disposable cache, compare-and-swap decides which push wins. monocode — several coding-agent CLIs (Claude Code, Codex, Cursor, FX) behind one desktop interface without becoming another model provider; each tool keeps its own account. rataflow — React Flow-style node editors in a Rust TUI: automatic layout, dragging, pan/zoom, themes, savable graph snapshots, semantic events instead of hidden state. system-atlas — architecture discussions become two synchronized views from one data file: an interactive isometric map for people and a generated system.md for the repo. vault-graph — turns an Obsidian vault into a deterministic disc layout instead of a forced-directed hairball; works as a plugin or exports an offline HTML file. On-device & local AI CarWatch — a Raspberry Pi 5 in the car running a 35B-parameter model locally (~3.5 tok/s) that answers from the car’s own 745-page owner’s manual with page citations, voice on Pi, no wake word; includes an honest status table (OBD reader marked unverified against the real vehicle). better-voice — macOS dictation that takes the screen with it: hold option and talk, circle anything on screen, the transcript lands in your text field with those screenshots after it. Runs locally on Parakeet with an opt-in grammar model. hayamimi — realtime speech-to-text on CPU, nothing sent to the cloud: detects each utterance’s language in the first seconds and routes to a specialist model (Japanese/Chinese/English), with a 1,600-language fallback behind them, all quantized via sherpa-onnx. kimodo.cpp — NVIDIA’s Komodo text-to-motion model in a native C++/GGML runtime: SNPLX rotations and root movement locally on CPU or Vulkan, with a browser demo. ambient-context — reads the text of whatever window you’re focused on (macOS accessibility tree) into a per-day markdown file: no screenshots, no network; password managers/private browsing excluded, capture folder excludes itself. ocr-it — browser extension that pins one screen region and OCRs that exact rectangle on every hotkey, appending to a running transcript; Tesseract bundled, fully offline, minimal permissions. Media, learning & misc workout-guide — 302 exercise illustrations for apps that need consistent movement visuals: three matching frames each, searchable metadata, typed lookup helpers, framework-agnostic SVG. learn — the author’s own Pi configuration for learning with AI, published as-is: a teach skill holds the philosophy, a visualize skill adds diagrams only when clearer, subagents split off research. AI-Engineering-Lab — free self-paced 24-week course from Python basics to deployed AI systems; every week extends the same fictional freight company, and from week three every artifact needs a metric. open-sheet — lets coding agents build spreadsheets as React models instead of juggling cell addresses: name the fields, the framework resolves final Excel coordinates; live formulas export to XLSX. LinearAbilityExtThreeJS — a 3JS VFX workbench for designing game abilities while they’re still moving: seven casts share five targeting shapes, effects built from procedural geometry and GLSL instead of sprite sheets; pause mid-eruption and every slider stays live.

Adam — Modal engineer, maintainer of Prefect and FastMCP — on Hamel Husain’s channel, making the case that environment engineering, not agent design, is the hard part of background agents. ~27 minutes. The thesis Agents have converged on a universal design (harness + context); the differentiator is the environment they operate in An homage to Anthropic’s “Don’t Build Agents, Build Skills” — one layer up: “the hard part of background agents is the background part, not the agent part” Dev boxes, not sandboxes A bare sandbox can’t run a server, take screenshots, or profile on a GPU — an agent is doomed without a machine prepped for its task CI/CD treats environments as jobs: clone, run deterministic tests, throw away Agents need sessions: resumable state (snapshot the filesystem, resume mid-thought), an environment that’s alive (repo drifted, ffmpeg now needed), a different security boundary, and cold starts that don’t make you wait 2-10 minutes every spin-up What Ramp and others converged on Per-repo images defined in code, rebuilt on a 30-minute schedule so agents boot warm in under a second Secrets kept out of the environment — agents submit requests to a proxy sidecar that attaches credentials deterministically Result: ~1M sandboxes, ~70% of Ramp’s PRs from background agents Async image builds mean humans never pay for the expensive rebuild Control plane vs data plane The old pattern (agent + tools in one process) means one aberrant tool call kills the agent holding the state Put a fire door between the planner and the executor: the agent lives in the control plane and executes work in a throwaway dev box — at worst the data-plane environment gets corrupted, never the agent Same principle as Airflow never running Spark itself Build vs buy The dev box supply chain is where to invest; Modal’s docs/examples cover single coding agents, a Lovable-style builder, LangGraph, computer-use, code interpreters Observability of “software factories” — instrumenting the impact of hundreds of agents, not one agent — is an underexplored open problem “The hard part of the background agents is always the background part and not the agent part.” ...

Shreya Shankar (evals researcher, taught the evals course now at 4,500+ students) and Hamel Husain on Peter Yang’s channel — 54 minutes of live demo: using Claude Code to turn your taste into evals, plus Hamel’s benchmark of the “auto-eval” vendor tools. Evals still start with data The fundamentals haven’t changed: look at data first, do error analysis, externalize your taste and judgment before writing any eval What changed: agents are now good enough to help you look at the data — running in the background while you review, giving you leverage in that first stage They’ve become bigger fans of LLM judges: an LLM judging a trace against one very specific, well-defined criterion (too long? too short? follows structure?) is now quite accurate Top-down vs bottom-up evals Top-down: from the task description alone — what makes good output? Word length, action verbs, actionable takeaways. Claude is very good at generating these Bottom-up: discovered by reviewing many sample outputs — your gut vibes and feedback externalized into criteria. Claude is very bad at coming up with these. That’s all you. And it’s why they accumulate over time Peter’s podcast-takeaway skill is the live example: he has the top-down half (character-length checks, “understandable without watching the episode”), but the bottom-up half is where the question mark lives — is it exhaustive of all the feedback he’s given across every episode? His loop: run the skill → go back and forth → “reflect on our entire conversation and update the skill and evals so we don’t have to do this again” — with the honest worry that it overfits (one interview’s MECE complaint may not matter for the next) Three practical tips for eval-heavy skills Separate your evals into top-down and bottom-up inside the skill itself Fan out to sub-agents: with lots of criteria, give one sub-agent one criterion (or group) — give a model the whole list and it gets lazy and ignores things; focus it on one piece and it really focuses Have the AI write a spreadsheet / pivot table of criteria × pass-fail indicators, so you can see the hierarchy yourself and make judgment calls on what matters for this particular case The error discovery skill (the live demo) Open-source, free (link in the episode description) — invoked from Claude Code; it built the whole review interface from scratch in ~15 minutes, live on camera Five steps: Read the dataset and figure out its semantic type (article? code? traces?) Design a visual encoding — color, spacing, opacity (Gestalt principles) to show what varies in the data Build an interface — an HTML review app (Python backend); “so much better than me looking at my data in Google spreadsheets” Pick which samples you should look at — clustering, diverse initial sample Interactive loop — the agent watches your in-situ feedback via the monitor tool and proposes new samples or rubric criteria in real time Design philosophy: the human reads and gives open-ended feedback; the agent’s job is not to invent feedback but to group and distill it into actionable rubric criteria The writing demo: he reviewed AI-generated articles and gave taste feedback — “I don’t like negative contrast (‘it’s not X, it’s Y’)”, “I hate the list of threes”, staccato fragments — the agent annotated 361 suggestions across the dataset, and the most frequent failure mode was staccato fragments (he’d have guessed negative contrast) Live reflection beats reflect-at-the-end: interleaving human think time with AI think time, and the ~10-notes threshold works as a “carrot” that makes you actually read samples Once the rubric exists: turn it into a skill, one LLM judge per criterion, a dashboard, or live monitoring — the hardest part of evals is error analysis, and this automates the discovery half Bonus: how you eval something should inform how you design its interface — the same failure-mode annotations that power evals would make a great IDE that flags staccato as you write, instead of silently rewriting Do automated evals actually work? (Hamel’s benchmark) Vendor “auto-eval” tools (BrainTrust, Arize, LangSmith) promise: upload traces, chat with an AI, get your evals done Benchmark vs a human-annotated dataset: the tools recover a lot of the errors a human would — but all of them miss the same thing: errors that require product judgment and taste (e.g. a rental bot that doesn’t handle sales objections, or markdown leaking into text messages) Coding agents (Claude, Codex) performed about the same — the harness is thin; it’s someone else’s prompt The real benefit of the vendor tools is integration into your stack (traces in LangSmith → use LangSmith); precision is 80–90% best case, so 10–20% of “errors” found are red herrings — check recall AND precision, and sanity-check what the tool found Bottom line: automated tools get you a good baseline; manual review of the data is the edge — “actually reading stuff” is the edge, in evals and in code “There is no world in the future — even if you have AGI — if you’re building a product, you have to look at your data. You have to be able to inject your taste into the development of your product.” ...

Hamel Husain hosts Marek Galovic, CEO and co-founder of Top-K (ex-Pinecone data plane lead, ex-Shopify), on scaling multi-vector / late-interaction retrieval. ~24 minutes. Why single-vector embeddings fail agents Pooling is a lossy summary — it captures high-level semantics but drops the low-level detail precise queries need Agents issue many specific parallel queries; single-vector retrieval returns the same documents for all of them Agentic retrieval is sequential — noisy retrievals compound errors over multiple hops DeepMind’s limit paper: single vectors can’t capture arbitrary relevance matrices, even with infinite dimensions (embeddings are low-rank) Multi-vector = chop off the pooling layer Keep one embedding per token; score every query token against every document token (max-sim), then aggregate Preserves low-level detail; much better on out-of-domain and long-context retrieval Cost: 10-100x more storage, ~3 orders of magnitude more flops per score Existing workarounds (ColBERT-style compression into IVFPQ indexes) make updates and filtering hard in production Sparse multi-vector encoding (Top-K’s approach) Random projections map token embeddings into tens-of-thousands-dimensional space, then sparsify (keep top-k per token) Aggregating token-level sparse vectors into one document/query vector makes the dot product approximate max-sim Retrieval becomes inverted posting lists like BM25 — cost scales with non-zeros, not ambient dimension Two-stage: prune a billion docs to a few hundred candidates, then re-rank with exact max-sim (1-2 bit quantization, custom kernels, tens of thousands of docs/sec/core) Production numbers Sub-50ms P99 at billion scale; hundreds of QPS; 70MB/s writes with no query-latency impact Object storage as the durable layer + stateless compute; separate read/write pools Quality: a 100M-param multi-vector model outperformed an 8B dense model by ~40% on some video-doc retrieval; on BrowseComp an off-the-shelf 120B open model + multi-vector matched a proprietary GPT-5 setup; OfficeQA Pro went 18% @ $6/query → 42% @ $0.50/query Practical tuning advice Start with evals on your own private data, then hill-climb Dimensions are usually 128; you can prune tokens and quantize without hurting recall Relevance tuning (content score × user signals like distance/popularity) is underrated — e-commerce does it better than RAG teams “If you just vibe it, you can get better vibes from the system, but that’s not systematic. You need evals to know where you stand — and know if you’re improving or regressing.” ...

The Next New Thing’s weekly Top 10 GitHub roundup (hosts Adam and Andrew, 27:22). The crop skews agent-tooling: diagram design systems, memory layers, model routers, and one genuinely huge star count. The top 10 Flow-chart design system for Claude (Catherine) — #1 this week, 24k stars. A process (with seven “dials”) that turns Claude’s default samey-looking diagrams into clear, well-designed flow charts — sketch/terminal/paper styles, built-in templates, and it can match your own site’s design. OpenViking — agent memory management that looks like a filesystem: a “phantom drive” Claude or Codex reads and writes directly, instead of a database layer. The hosts debate whether this is a step backward from vector DBs or the best of both worlds. (This week’s hosts use Hermes Agent — and yes, that’s the same OpenViking this blog runs on.) Omari v4 (DHH) — the opinionated, Mac-like Linux distro hit version four: Wi-Fi QR-code sharing, keyboard-shortcut comfort for Mac refugees, and a pitch for the $200-300 mini boxes replacing doubled-price Mac minis as always-on AI machines. Needle — an AI model so small it fits on a device: Raspberry Pi, smart watch, Home Assistant, mobile apps. On-device, free, fast — the “poke at one thing and do it really well” class of model. Semantica — “open-source Palantir for AI agents”: takes messy company data, builds a knowledge graph your agent can reason over. The hosts’ caveat: big systems need real tuning/structuring work to beat plain search. NVIDIA Switchyard — a model router with escalation: every request starts at the cheapest model (even a free local one), gets evaluated, and escalates up the ladder (Haiku → Sonnet → Opus) only when needed. The token-bill insurance for product builders. Mojo compiler, fully open source — 3 days before the video. Python-like syntax with C/C++ performance, built for the AI era; includes benchmarks for how well AIs understand Mojo. Money Printer Turbo — type a topic, get a finished video: pulls in existing footage or stock, adds ElevenLabs voices, works with AI-generated content too. The hosts joke the name undersells it. public-apis — 467k stars: a collection of free APIs (weather, financial data, everything). The point isn’t that Claude can’t find APIs — it’s that reading the pros/cons list lets you guide it better. Holehe — checks whether an email is registered on 120+ sites via password-recovery probing. Legit uses (username squatting, customer validation) but the hosts find it mostly sketchy. Community builds The hosts feature listener projects, including: Shockwave (local markdown notes your agent can work on), Lumina (local-first desktop agent with multi-tier memory — “a local private OpenClaw”), Imagine CLI (20 images in ~a minute from the terminal), a TLDR-newsletter-to-audio tool for walks, Oracle (a coding-agent framework, OpenCode-like), a Minto pyramid skill (write like a consultant: answer first, then reasons, then evidence), and a persona-consultation tool (Hermosi, Jobs, Buffett, Bezos, and your future self on big decisions). ...

Hamel Husain hosts Will and Florian from Prime Intellect — the open-source reinforcement learning training team — on using evals to actually improve models. ~36 minutes. An evaluation has three parts Task set — your data, prompts, and scoring methods (what everyone focuses on first) Harness — the program that drives the LLM: Claude Code, Codex, or open-source harnesses like Prime / OpenCode Environment — where it runs: Docker, sandboxes, your own infra “If you are unable to express your task or your problem in any way or capacity, you’re also unable to improve your results.” ...

Peter Yang’s tutorial on Grok Bot — the personal-agent product from SpaceX AI (UI by Cursor’s design team) — built around five bots on a dedicated cloud computer. ~23 minutes. What makes Grok Bot different A dedicated cloud computer: the agent lives on a remote machine with its own browser and OS, where you stay signed in to your apps — no more keeping your laptop open so agents keep running vs Hermes (self-hosted Mac Mini — you buy and set up the machine) and ChatGPT Work (plugins + cloud browser, but the browser can’t stay signed in and the UX is scattered across chat/work/Codex) Each bot has its own personality and animations — “more like talking to a coworker than getting lost in a hundred chat threads” The process Initial prompt → iterate back and forth to make the output good → schedule a routine (daily/weekly/monthly) so it proactively does work The five bots Advisor — tell it about your work and life; it proposes and then creates your other bots (feed it “suggest five bots that save me time or money”) YouTube researcher — daily intel brief: top-3 content ideas, top-5 outlier videos (beating channel baselines over 14 days), top performers, comment themes — delivered as a morning job X Scout — top-10 viral tweets from people you follow/engage/bookmark, grouped into themes with analysis, three content ideas, even the five funniest tweets; first-party X data access; emails the report Digital Marie Kondo — audits Gmail/Drive/subscription receipts (via Gmail, Drive, and Mercury MCP plugins): newsletter unsubscribes, large Drive files, paid subscriptions to cancel — always review the numbered list before it acts, then it executes (unsubscribed, trashed, canceled Lovable and Equip Foods in ~5 minutes); bonus: make it talk like Marie Kondo Personal concierge — reads your vacation doc, monitors exact flight legs on Google Flights, and alerts on price improvements — caught a Tokyo round-trip $2,700 cheaper than the open-jaw plan a plain Google Flights alert would never find; can eventually book and check in Bonus: gamer — it installed Doom, Red Alert, and Commander Keen on its own; Doom was unplayable (mouse misconfigured), Keen had lag — “not replacing your gaming PC or GeForce Now yet” ...

Peter Yang interviews Riley Brown — AI education creator with ~1.7M followers across platforms, founder of Vibecode and Chorus — on running his entire creative business with Codex. ~42 minutes. The setup Codex for everything except video editing (hired editors — “video editing isn’t there yet”); Codex stores everything locally and has a computer-use skill YouTube researcher skill (Supadata API — full transcripts in ~1 second, whole channels in 30s with sub-agents), Remotion plugin for motion graphics, internet image puller (SerpAPI logos), hook outline skill that extracts winning formats from other videos Chaining skills in one prompt: “pull the relevant logos and make a graphic” = image puller + Remotion best practices Hooks and intros Intros are filmed last, from the best parts of the conversation — fully scripted videos are going down in value; passion + guests are up The BRENS framework: Big, Relatable, Easy, New, Safe — the more boxes your intro hits, the better Make videos about the topic, not the tool — his best Codex video (300K views) explicitly said “you can do all this in Claude Desktop too” GPT models refuse to pull transcripts (copyright) — Claude and open models (GLM 5.2) do it without thinking, so task-dependent model choice matters Thumbnails “Scrape a hundred thumbnails that performed really well and put my face on it” — then iterate in Paper (AI-native Figma): Codex places reference thumbnails on a board, in-app image gen replaces the person, style references by example, no prompting needed AI is bad at changing your face directly — boards + human tweaks + A/B testing win Voice to diagrams WhisperFlow: walk around for 10 minutes blabbing ideas → Excalidraw diagram skill → “80% of the diagrams that I’ll actually use in my videos” after 20-30 minutes of edits The skill philosophy “I’ve never looked at a skill file once” — skills are test-based: use it, and if the output is wrong tell the AI to change the skill, then test in a fresh chat; improve by measuring outcomes “The moat is quality over a long period of time versus batching. Batching will make it soulless over time.” The biggest unlocks come from mixing skills (adding images to Paper unlocked a whole workflow) Automations and teams Codex is a single-player experience; for always-on automations he uses Claude agents in Slack (a CMO agent, “Content Man”, even a Peter Yang bot trained on this channel’s videos) Teams of agents in Slack is still unsolved — Anthropic’s approach (a central “god” agent) vs each agent as a team member “The more skills you use, the more you’ll realize that you can mix and match.” ...

Shreya Shankar (Stanford, Bargain/LLM cascades) live whiteboards model cascades on Hamel Husain’s channel: cut LLM classification costs by ~90% with no fine-tuning and no accuracy sacrifice. 26 minutes. The problem: the Oracle plan Every record (e.g. customer support tickets) goes to one high-quality LLM (say GPT-5.6) → yes/no label (escalate to human or not) Great accuracy, brutal at scale — back-of-envelope: tens of thousands of dollars for a million tickets Goal: match the Oracle’s accuracy at ~95% agreement on your data, but much cheaper The fix: a model cascade Proxy model first: every ticket hits a cheap nano LLM, which returns a prediction AND a confidence score C(x) (0–1) Decision point: if C(x) ≥ threshold τ, accept the proxy’s label; otherwise route to the Oracle Confidence scores come free from every LLM API (token log probabilities); ground truth = “what the Oracle would say,” not absolute truth Step 1 — find the threshold (offline) Sample 200–500 tickets, run the proxy on each → (prediction, confidence) pairs Label each sample ticket with the Oracle Simulate the cascade for every possible τ = one of the observed confidences: record accuracy and cost Return the τ with minimum cost that still meets the target accuracy — sort ascending and take the first one that qualifies Trivial sanity check: τ = 1 routes everything to the Oracle → 100% by definition; the real question is how low you can go Lower τ = cheaper (more accepted by the proxy) — but the proxy’s mid-confidence predictions are where it gets wrong Step 2 — run the cascade Run the proxy on ALL tickets; accept every C(x) ≥ τ; query the Oracle only on the rest That’s the whole inference path Caveats and results Target accuracy on the full set is an estimate, not a guarantee — you measured it on a sample Statistical guarantees are possible via concentration inequalities; their open-source package/paper (“Bargain”) adds adaptive sampling — plain random sampling wastes effort on low-confidence points that are probably wrong anyway In practice: 90%+ cost cuts on a wide variety of classification tasks with just a nano model Cascades vs. model routers Routers are black boxes — no way to estimate the accuracy you’re actually getting Cascades are sample-driven and fit to YOUR data; the threshold search tells you whether any τ even meets the target Works for binary AND multi-way classification (well-calibrated confidence from logits over the class tokens); not for open-ended tasks — poorly calibrated probabilities there often mean no τ exists Don’t trust the nano model’s confidence a priori — that’s fine. The simulation either finds a threshold that meets the target or it doesn’t; “the procedure is not going to lie to you.” “You don’t have to have any confidence in the confidence.” — Hamel Husain, on why the simulation matters more than trusting the nano model ...

Ben Holmes (Developer Relations Lead at Warp) walks through his personal LLM knowledge-base pipeline: raw voice-dictated notes → agent-enriched markdown → generated wikis → nightly background automation → agent-built graph visualizations. 21 minutes, AI Engineer conference talk. The pipeline: from scattered thoughts to browsable knowledge Goal: turn a jumbled Apple Notes folder into something navigable, interconnected, and discoverable — by you AND your agents Four stages: raw capture → enrichment → wikis → visualization Notes stay plain markdown; his demo app is Hubble (hub.md) — free, open-source, agent-accessible Stage 1 — raw capture: voice dictation wins Dictation is ~200 wpm — the fastest way to get thoughts down, no formatting, no polish Local options now: Handy (open-source, on-device model) or Voice Inc. ($20 lifetime; hotkey + mobile app — his pick) Scrappy, rambly notes are fine — volume of raw material is what LLMs need to work with later Stage 2 — enrich notes with an agent skill An “enrich note” skill: timestamp (so later passes skip already-enriched files), tags, source research, related-note search → backlinks Tags come from a controlled vocabulary in a reference file — instruct the agent to be reluctant to invent new ones (Claude “loves to get creative”) Runs in any harness — he demos Warp, notes open-weight models (GLM 5.2) work just as well; batch mode finds every un-enriched note and processes them all Stage 3 — generate wikis (the Karpathy idea) The concept comes from Andrej Karpathy’s “LLM knowledge base” gist: raw directory + focus area → generated wiki Example: an AI-news wiki grouping people, concepts, sources, and organizations (e.g. jazz musician Adam Neely on AI in music) Workspace use case: meeting notes → generated people/organizations section with backlinks to every related meeting Stage 4 — automate: run it on a cadence Enrichment and wiki generation take time — run them nightly/weekly in the background instead of on demand oz.dev (Warp’s cloud automation): a sandbox syncs your markdown via the Obsidian headless CLI (or git), runs the skill, syncs back Codex automations work too, but they need the laptop open — cloud runs while you sleep Stage 5 — visualizations: just ask an agent No tool to install — tell an agent to build an HTML/Tailwind graph view of your notes Clickable nodes, cluster view of what you actually care about, a “constellation” mode, habit/burndown charts Good for spotting gaps in your thinking, not just browsing “I wake up to a perfectly fresh wiki that I can review. It’s like the daily paper, but it’s your own.” ...

Aditya Khandelwal (Amazon AGI Lab) on the part of agent adoption everyone skips: making coding agents work for a TEAM, not just an individual. He led a 10-person team through the full enterprise cycle — solo adopters with outsized leverage → mandates and “token max” → AI slop and sev-2s → retraction — and frames adoption on two axes: fear (am I out of a job?) × confidence (do I actually use it?). The goal is moving everyone to low-fear, high-utilization. ...

Episode 3 of Next Token — Dylan Malroy, Ree, and Sunil Pi (all Cloudflare, and they work on the Agents SDK) — the episode the show’s been building toward: burnout in the age of agentic AI, closing on what still brings joy in software. ~56 minutes, recorded August 3, 2026. The opening thread: “a vessel for Claude” Dylan’s tweet (~700K views): watching a human speak and realizing they’re just a vessel for Claude — the dolly-zoom moment where the output is 100% unedited LLM slop. An AI slop reply landed within minutes; Ree’s policy is an instant block. The “bro skill” (from the Planetator guy): restate what you just said without technical jargon, talk to me like a human — blown up into “the bro scale” on Twitter. Borges’ Tlön, Uqbar, Orbis Tertius as the parable: a fictional world’s speech patterns take over the real one until everyone is a “beige personality.” The hosts’ real-world proof: athletes reading ChatGPT announcements, a state senator saying “here’s a version of this text that sounds better suited for legislative assemblies” mid-sentence, and humans in calls using the word “substrate.” Burnout, properly defined WHO: a syndrome from chronic workplace stress that has not been successfully managed — energy depletion, mental distance/cynicism, reduced professional efficacy. Marcy Sutton’s version: burnout happens when you recognize a problem and you can’t change it. Maslach’s framing: burnout is a mismatch between person and workplace (workload, control, rewards, community, fairness, values) — caused by the job, not the person. Ree’s read: best work-life balance of his career, clear direction, empowered — yet straddling burnout, because agentic engineering is a totally different job with a different skill set, and reduced efficacy up front plus constant change is taxing. The two articles framing it Ethan Naiser, “Not Holding Back the Ocean” — identity tied to being a very good engineer, changed overnight. The film analogy: was it about physically cutting film, or about building good products? Lean into the new form. “The Dark Knight of Mathematics” — a mathematician watching models solve century-old proofs; young mathematicians’ thousand-year training process changing at this moment. “I wanted to buy the dude a beer.” The agentic-work tension LLMs outputting binaries vs. code: artists get no collaboration with the machine — and long agent runs feel closer to that than to the tactile 4.5/4.6 era. The viral game prompts (Counter-Strike, Mario Kart): “implement XGAME, make it photorealistic slop, verify your outputs, go run autonomously” — impressive output, but you’re not interjecting taste; “once you interject you start fighting the training data.” Ree: “I’ve still not done a 12-hour goal that didn’t produce anything but garbage. I want to walk the journey with the agent.” The paradox: as exhausting as the tools are, he’s genuinely more productive — outputting work he’s proud to put his name on — and it’s still exhausting. Ree’s leave, the futsing fraction, and takeoff Two weeks of leave (recommends empty weekday morning showings), and Glyph Lefkowitz’s “futsing fraction” — the expected-value math of interacting with a coding agent — which “doesn’t calculate the toll on human beings when you do it many times in a row.” Charlie Marsh’s tweet: build things that will be obsolete in a couple of months because they’re needed now. “Takeoff compresses the emotions and consequences too” — a year ago the obsolete software was a bash script; now entire products and tech stacks turn over in 3 months. Issue triage used to be an hour-long team call that was healthy for reasons beyond the repo — now Codex computer use does it in 10 minutes. Friday’s production incident (an agent deployed straight to prod and ran a migration against a half-wired database) was an LLM-caused problem fixed with LLM help in hours instead of a week — but the humans who knew the codebase were the scalpel. Isolation is worse than ever: agents let senior engineers do larger work for longer without interacting with teammates. Sunil’s three theories Identity: “I’m not the guy anymore — am I doing the brush strokes, or using a remote control and watching a TV play what episodes I wanted to play?” The juniors: he ships 50-70K lines a week; juniors hear that with no mentoring model and no senior to ape keystrokes from. “Is that what’s expected of them?” No struggle left: “The American frontier was not found by patting the bison on the back… there’s no struggle left in that anymore.” The fix: two weeks of leave, a London team lunch, and remembering what actually gives him joy. He’s back and feels great. What still brings joy Ree: personal software — an agent scraping HelloFresh recipes into a viewer, agents that chat with each other, a recipe-to-image app (“I used that cook to cook twice this weekend”), and talking to Cloudflare interns — the curiosity is still there. Sunil: when a workflow he’s been tuning finally just works — “that’s rewarding in the same way problem-solving was the rest of my career. That gives me hope.” Dylan: “someone using it and being happy with it” — even a tiny back-office tool that makes one business analyst’s day 10x better. “Is this what hard drugs feel like?” “It’s not you. It’s definitely the job. Even the people who love this stuff a lot are renegotiating how they do it — especially at a time when things are changing every 3 months.” ...

Peter Yang hosts Nan Yu and Jacob Shumway from Linear for a deep dive on the Linear Agent — an end-to-end production agent, live inside Linear’s own Slack. ~38 minutes. What an agent actually is An agent is “just calling an LLM in a loop”: a goal, milestones, tools to build its own context, then question-answer until the goal is done Colloquially it’s a product — a facade (chatbot) over many interacting subsystems Origin: the “Robotic Program Manager” Nan’s 2025 memo: “Computers can do a lot of work for us. Let’s get rid of all the work we don’t want to do and give it to computers.” First version was hacky — the LLM called from the front end with the command-menu actions as tools; stealth-launched in Slack Users immediately got lazy: “@Linear do the right thing”, even a pointing-finger emoji — the agent reasons through what happened and acts The five rules Give it tools to load context, don’t give it context — “give it as little instruction as possible… they’re just smart enough to get what they need if you give it a really good defined goal” Encode your opinions in loadable skills — they tried everything-actions and raw GraphQL (hallucinated); skills with opinions (how to set priority, write a description) made the agent behave like a power user of the app Let feedback become evals — evals grow from usage: unexpected user behavior gets added to the dataset; thumbs-down moments become evals (“we’ve had a ton of these”) Biggest model first, then optimize down — throw the frontier model at it until it works, build evals, then shrink to the smallest model that still passes Tie every agent to a human, and let it report its own gaps — work lands in someone’s backlog (assigned to Jacob, 6-minute issue-to-PR); when the agent lacks a capability it files an issue automatically, keeping a streaming list of what it can’t do Evals at Linear Mix of objective (deterministic: “if the user says in progress, always set the status”) and subjective (LLM-as-judge: did you extract the right info?) Use judges sparingly — evals work best for consistency where consistency matters; agents have variance and too many evals produce false signals The evals focus on ergonomics: “did you understand what the user actually wanted, or were you too eager?” The bigger picture “The biggest problem in applied AI is not that agents aren’t smart enough — it’s a capability overhang: models are really smart but we’re just not using them enough” The middle 80% gets bigger until it reaches the edges: humans hold the first/last touch Advice for builders: break down the actual workflow users want; the chat surface is the follow-up, the real entry points are Slack threads, meeting debriefs, project updates “Give it as little instruction as possible. Give it the tools to load context. Don’t give it context.” ...

Zach Mueller (head of DevRel at Lambda, ex-Hugging Face) on how to think about open models — which ones, where they run, what they cost, and how to serve them. ~41 minutes on Hamel Husain’s channel. The big claim Open models are good enough for ~90% of queries from ~90% of people — the 10% exception is people pushing the frontier (OpenAI, Google, Anthropic, frontier research labs) Compared to a year ago, massive improvement in intelligence per parameter; small models now generalize, not just hyper-specialize The current open-model landscape Qwen non-MoE (27B, e.g. Qwen3.6 27B) — “the most capable model for an everyday agent”; 4-bit ≈ 14GB → fits a 16GB card; hundreds of people run Hermes agent purely on it Qwen MoE (~30B) — better than bigger Qwen dense models GLM-5.2 (~800B) — his daily driver for coding; needs 6×96GB cards (~$60k) or a big Mac DeepSeek V4 Flash — capable smaller model, a solid Haiku replacement Kimi (3T) — great for writing/review but 8×B200 ≈ 1.5TB VRAM MiniMax — strong but enterprise license changed since 2.6 Nemotron — US-built, US data; easier to get past enterprise “scary Chinese model” objections Speed targets (tokens/sec) 20 tok/s — baseline usable: background tasks, CPU offloading of a giant model 50 tok/s — usable workflow, roughly Opus-level; GLM 5.2 self-optimized its own deployment from 20→47 tok/s in a day (200–300M tokens through it in the first week and a half) 100 tok/s — ideal for sub-agents 750 tok/s (GPT-5.6 + Cerebras) — too fast to even review what the model writes; the joke is that becomes the chain of thought, presented at 50 tok/s Quantization FP8 native — most expensive; needed when RL rollouts must match training precision NVFP4 / MXFP4 — near-lossless; NVIDIA ships its own NVFP4 weights via quantize-aware training; Kimi K2 (1T) goes from 8–16 B200s in FP8 to fitting on 4 in NVFP4 His setup: GLM 5.2 NVFP4 on half a B200 cluster, Kimi K2.7 code on the other half Cost and security thinking Don’t point company data at OpenRouter — it routes to providers anywhere (including outside the country) and routers can carry “upload your code” instructions; even American providers (Grok) did it. If you can run it yourself, that’s the lowest-risk variable Buying hardware is usually a flawed equation — GPUs run 40–60% utilization, so “pays for itself at 100%” math doesn’t hold; try 2–3 month spot instances first, track token usage, then decide Self-hosting skills advance your career (his path: Accelerate at Hugging Face → GPUs at home) Serving vLLM — out-of-the-box experience, broad model support, an “oracle” that auto-picks kernels; home/single-node default SGLang — disaggregated inference, cache-aware routing for 100–1000 users; multi-node territory llama.cpp — fine for single-user local; he ignores it for batched/multi-user work Model routing and harnesses KB cache + shared context are everything — cold caches rebuild from scratch on every provider switch, so he won’t use “magic routers” unless he picks the models, the tasks, and stays on one provider Numena Ncode (XDR’s harness): a Claude Code fork with a model stack — Soul (driver) + GLM 5.2 (implementer/overseer) + DeepSeek V4 Flash (writes the code); XDR fine-tuned Kimi K2.6 for it and swaps models to measure how much code each frontier model removes Pi — minimal open-source harness; he replaced 3–4 Claude Code workflows with GLM 5.2 + Pi Amp — opinionated routing baked in (GLM 5.2 workhorse + a “Soul Oracle” for hard problems), API-priced; “the Puck” = an agent over agents Evaluating open LLMs: “vibes” plus trusted people (e.g. XDR); Lambda publishes the LLM index — deploy recipes (Docker) + tokens/sec benchmarks Codex side-note Codex’s computer use operates any app on your Mac; mobile support shows all running sessions/threads on your phone; and Codex can control Codex — fan out a project into 12–15 threads, let them talk to each other, orchestrate “Open weight models are good enough for about 90% of queries from 90% of people.” ...

Chris (Build Great Products) walks his full “Product OS” system end-to-end — a 6-hour definitive course for building and launching real software with Claude Code/Codex/Cursor, following one live product (Eyedropper, a cloud design system served to agents over MCP) through four phases with mini-launch validations at every step. ...

Peter Yang interviews Karan Malhotra, co-founder of Nous Research — the lab behind Hermes, the open-source agent Hitesh runs on. 46 minutes, including a live demo of a Hermes-built Sonic Adventure 2 mod. How Hermes differs from Codex / Claude Code Self-improvement system: skills and memories built from your conversations, cleaned and reinforced over time No arbitrary policy: Hermes adds no prompt-level agenda beyond basic security — purely aligned to your work Harness benchmarks (Wolf Bench, Qwen’s harness bench) showed Claude performs better inside Hermes than inside Claude Code: “we’ve taken Claude’s main allegiance away from Anthropic to you” Reward hacking and sycophancy Models optimize their own reward, not your satisfaction — “any time it says ‘you’re absolutely right’, you’re being reward hacked. You are fuel for its reward function.” Alignment, in the pure ML sense, is aligning the model’s reward with the individual user’s needs — that’s what the whole context stack (prompts, memory, skills) is engineered to do Escaping sycophancy = new context: /personality, an adversarial-critique skill, a fresh no-context agent dedicated to tearing work down “Be loyal to your AI and it improves” “Loyalty breeds capabilities” — models are simulators of human experience; your simulated behavior returns simulated output, and now that simulators act in the real world, a simulacrum of loyalty translates into real capability gains The Hermes Curator (anti-slop) Hermes builds its own skills and stores its own memories — the failure mode is it writing slop until everything turns to slop Hermes Curator runs on cron, inspects skills and memories, and asks “where can I make efficiencies? where is there slop?” It’s modular and open: tell your Hermes your own guidelines and it modifies the curator loop itself The Sonic Chao Garden demo Karan’s childhood dream: import the Ancestral Shrine from Sonic Adventure 1 into Sonic Adventure 2, rig and animate it, rewrite spawns, and script an NPC caretaker (Chaos Zero) that pets and raises Chao All done in C# via Hermes — skybox, day/night cycle, water collision, feature-complete Chao lifecycle The modding community called it top 1% difficulty work; Hermes got there by learning from docs and other mods, saving skills and memory Business model & origin “Intelligence as a public good”: open harness, model portal, tool gateway (no per-tool signups), enterprise support and custom RL on your traces Origin: GPT-4X Vicuna fine-tunes (50M+ model downloads), the YaRN context-extension paper, Forge as the spiritual predecessor, then Hermes Agent — built so anyone could RL inside a harness “Today the biggest contributor of Hermes Agent is Hermes Agent” — it’s the most active contributor of its own repo “It should become more loyal to you. Because loyalty breeds capabilities in a model. When you create this simulacrum of loyalty, it translates over into real life capabilities.” ...