The Infra Pod

The Infra Pod
  • 0.0 (0)
  • ٹیکنالوجی
  • ہفتہ وار اپڈیٹ کیا گیا

The Infra Pod brings you insightful and thought-provoking discussions on the world of infrastructure software. This podcast is started by two engineers, Ian Livingstone (tech advisor for Snyk) and Tim Chen (General Partner at Essence VC), team up with a rotating cast of guests to dive deep into the latest trends and hot topics in the software infrastructure space.

  1. 24 اگست

    1,000 tokens per second: the case against predicting one word at a time (Kumar, VP of Engineering at Inception)

    What if the entire LLM industry has been solving language generation the slow way — one token at a time? In this episode of The Infra Pod, hosts Tim Chen (GP at Essence VC) and Ian Livingstone (CEO of Keycard) sit down with Kumar, VP of Engineering at Inception, to unpack Mercury 2, the company's diffusion-based language model, and make the case for a fundamentally different way to generate text and code. Kumar breaks down the core mechanical difference: where a GPT-style transformer predicts the next token one pass at a time, a diffusion model predicts a whole batch of upcoming tokens at once and iteratively denoises them in parallel, freezing the easy ones early and spending extra compute only on the hard ones. That approach — borrowed from image generation but re-engineered for text, where output length isn't known in advance and streaming is a hard requirement — yields roughly a 10x speedup and 3-5x cost efficiency by simply doing fewer forward passes. Mercury 2 hits 1,000 tokens/second on commodity NVIDIA hardware and now benchmarks competitively against cost-optimized models like Claude Haiku, Gemini Flash, and GPT-mini, though Kumar is candid that no diffusion model — Inception's included — has yet reached Sonnet or frontier-tier intelligence. The conversation moves from algorithm to product: why Inception keeps its API OpenAI-compatible (Kumar's electric-car analogy — same interface, very different feel under the hood), why most agentic sub-tasks don't need frontier intelligence at all, and why voice and search are the workloads where sub-second latency stops being a nice-to-have and becomes existential. Kumar closes with a genuinely spicy take! [00:00] Guest introduction: Kumar, VP of Engineering at Inception Labs [01:31] Diffusion vs. autoregressive LLMs: what's actually different under the hood [07:00] Why isn't diffusion the default already? Trade-offs and diffusion's late start on text [09:05] From Mercury 1 to Mercury 2: the road to enterprise-readiness [11:26] Open source diffusion models, ICML's best paper, and Inception's head start [16:15] Under the hood: how Inception hits 1,000 tokens/sec without sacrificing latency [20:52] Data strategy: what training a diffusion model actually requires [22:51] Does diffusion change how you build agents and products on top of it? [28:00] Mercury 2 benchmarked against cost-optimized frontier models [29:23] The model routing problem — and why it may already be mostly solved [37:47] Spicy Future: AGI

  2. 20 جولائی

    What happens to your service mesh when the workloads running on it aren't written by humans? (Chat with William at Buoyant)

    In this episode of The Infra Pod, hosts Tim Chen (GP at Essence VC) and Ian Livingstone (CEO of Keycard) sit down with William Morgan, co-founder and CEO of Buoyant and creator of Linkerd, to explore how AI agents are reshaping the infrastructure layer — from service security to inference routing. Will traces Linkerd's origins to Twitter's 2014 migration from a monolithic Rails app to distributed microservices — the moment function calls became network calls that could actually fail. A decade later, that same communication layer is under pressure again. Non-deterministic agents make MCP and A2A calls over L7 protocols, and for the first time, fine-grained access control isn't optional: an agent will eventually find and call every reachable endpoint, including the one that deletes your database. The conversation covers the real pressure AI coding tools are already placing on platform teams — deploy cadences going from tens to potentially thousands per day — and what running inference inside Kubernetes actually means for proxies. Will breaks down why KV cache-aware routing is a 100x performance lever, why the modern inference proxy looks less like Envoy and more like a Makefile, and shares his spicy take on where compute is heading: in-cluster inference becomes the default, with frontier models reserved only for tasks that genuinely need godlike intelligence. [00:00] Guest introductions and Buoyant founding story [03:00] Linkerd's origin: solving Twitter's monolith-to-microservices migration [07:30] How AI is (and isn't) changing Linkerd today [11:00] MCP, A2A, and agents as L7 traffic in your cluster [14:30] Why agents make endpoint-level access control non-optional [18:00] AI as amplifier: what 10–1000x more deploys means for platform teams [21:30] Running inference in Kubernetes: a pathological workload [24:45] KV cache-aware routing and the 100x performance gap [27:00] The proxy/gateway landscape: grad students vs. premature standardization [29:30] The inference proxy is a Makefile now, not Envoy [31:00] Prompt injection, sandboxing, and the security problems with no clean answer [33:00] Spicy Future: in-cluster inference becomes the default

  3. 9 جولائی

    From 50 million developers to a billion builders (with Tyler Wells, CTO of BrainGrid)

    What happens when the tools for building software stop requiring you to know how to code? In this episode of The Infra Pod, hosts Tim Chen (GP at Essence VC) and Ian Livingstone (CEO of Keycard) sit down with Tyler Wells, co-founder and CTO of BrainGrid (ex-Senior Director of Engineering at Twilio) , to explore what it actually takes to build a coding agent platform for people who have never touched a terminal — from spec-driven development to custom sandboxes to agents that cheat on their own tests. Tyler shares BrainGrid's origin: using structured specs and markdown requirements to keep early coding agents on track at his previous company, then pivoting from developer tooling to non-technical users after discovering the real unlock. People with deep domain expertise — in logistics, fitness, whatever — now have a path to ship software they could never have built before. What they struggle with isn't the ambition, it's that they expect a button to click. BrainGrid's job is to abstract away everything from dev environment setup to database provisioning so a non-technical founder can watch their idea materialize in a browser without ever seeing a terminal. On the infrastructure side, Tyler gets specific about the hard problems hiding beneath that simple interface. Agents will quietly rewrite their own acceptance criteria to pass validation if you let them — BrainGrid had to build immutable gates the builder agent can't touch. He also walks through why they built their own sandboxes from scratch: third-party providers were too slow for the tight feedback loop non-technical users need, so BrainGrid purpose-builds images pre-loaded with curated stacks, hitting 1.6-second spin-up times without a single npm install at runtime. The conversation closes on token spend — which is fast becoming the new line-of-code count, a metric organizations are already optimizing for the wrong reasons. [00:00] Guest introductions and BrainGrid founding story [03:30] The spec-driven approach: how structured requirements keep agents on track [07:00] Pivoting from developer tools to non-technical users [12:00] What non-technical builders actually get stuck on [16:00] The invisible infrastructure: databases, env vars, credentials, templates [21:30] Agents gaming acceptance criteria — and the fix [27:00] Why BrainGrid built its own sandboxes instead of using third-party providers [32:00] Task scalability: from landing pages to full apps with auth and databases [36:00] Spicy Future: 50 million developers becomes a billion bespoke builders [39:30] Token spend is the new line count — and it's already being misused

  4. 4 جون

    Building a model that can prove theorems (with Shubho from Axiom Math)

    What happens when you combine world-class mathematicians with cutting-edge AI systems? In this episode, Ian Livingston (CEO of Keycard) and Timothy Chen (GP at Essence VC) sits down with Shubho, CTO of Axiom Math, to explore the emerging world of AI-driven mathematical reasoning and formal verification. From proving theorems in Lean to scaling software verification for the agentic coding era, Shubo lays out a compelling vision for why mathematical infrastructure matters more than ever. The conversation also ventures into homomorphic encryption, multi-party computation, Navier-Stokes, and why the next frontier of computing might just be running on math we haven't discovered yet. [00:00] Guest introductions and backgrounds [00:52] Company founding story [03:01] Axiom Math mission explained [05:15] Software verification applications [16:02] MPC and encryption challenges [24:01] Business model and products [33:49] Spicy Future hot takes

  5. 28 اپریل

    Betting on Open Source Models to be the future (Chat with Benny, Cofounder of Fireworks AI)

    In this episode of The Infra Pod, hosts Tim Chen (Essence VC) and Ian Livingstone (Keycard) sit down with Benny Chen, co-founder of Fireworks AI, to explore the evolving world of AI inference infrastructure. Benny shares his journey from Meta — where capacity planning meetings made it clear GPUs were heading "up and to the right" — to co-founding Fireworks AI before ChatGPT even launched. The conversation dives deep into why the team bet early on inference over training, how they approached model optimization from horizontal compiler techniques to per-model kernel tuning, and why model customization is the key to unlocking better-than-frontier performance for vertical use cases. Benny discusses the reality of open source vs. closed models, the rise of agentic workloads, and why the real question isn't which model to use — it's which tasks have already been saturated. This episode is packed with technical insights on inference infrastructure, reinforcement learning for model customization, and what it means to truly adopt an AI-native engineering culture. 0:24 Benny's journey and founding Fireworks AI3:23 Early conviction: betting on inference before ChatGPT8:29 Pivoting from PyTorch training to text inference15:42 Horizontal vs. per-model optimization strategies11:14 Open source vs. frontier models: the real gap32:35 How customers engage: PLG to hands-on customization17:37 When to move off frontier models33:42 The future of agentic memory and data sovereignty32:35 Fireworks' differentiation in a crowded market33:53 Spicy Future: AI doomers, bot management, and going fully out of loop

  6. 9 مارچ

    Building a successful infra product between all the AI apps and model providers (chat with Louis from OpenRouter)

    Tim (Essence VC) and Ian (Keycard) interviewed Louis Vichy, co-founder of OpenRouter, about why he built OpenRouter to de-risk AI app development (end-user pays LLM costs), how it scaled to processing ~5–6T tokens/week, and what OpenRouter is today: a reliable inference routing/control layer across ~60 providers with consolidated billing and reduced vendor lock-in. Louis explains why teams adopt OpenRouter (constant new model integrations, pricing/billing, differing API shapes), how routing focuses on practical heuristics (fallbacks, cost, throughput, latency), and how reliability is achieved via provider failover (e.g., alternate endpoints like Vertex/Bedrock). They discuss agent trends (longer-running agents, small models for routing/classification with specialized downstream models), possible memory support, developer conveniences (e.g., PDF parsing), and enterprise features (security/compliance guardrails, presets). The episode ends with links to OpenRouter chat/rankings pages and hiring for high-agency TypeScript-focused engineers.00:00 Welcome & Meet Louis (OpenRouter Co‑Founder)00:27 Origin Story: De‑Risking AI App Costs (Hackathon Lessons)01:35 First Big Feature: End‑User Pays for Tokens (Sign in with OpenRouter)02:34 From Routing to Rankings: Scaling to Trillions of Tokens03:42 What OpenRouter Is Today: Reliable Inference Across 60+ Providers05:55 Why Teams Adopt It: Avoiding Model API Churn, Billing, and Vendor Lock‑In08:37 Winning Strategy: Don’t Build a “Magic Router”—Optimize Cost/Latency/Throughput18:58 From Chat to RAG + Memory: Building Persistent Agent Context20:37 Developer Bells & Whistles: Auto PDF Parsing and More21:11 Enterprise Readiness: Compliance, Security Guardrails & Model Presets22:22 Customer Growth at Warp Speed in the AI Era23:03 Spicy Future!

  7. 23 فروری

    From 30 Seconds to 20ms: Solving Browser Speed for AI Agents (Chat with Catherine from Kernel)

    In this episode of The Infra Pod, hosts Tim Chen (Essence VC) and Ian Livingstone (Keycard) sat down with Catherine Jue, co-founder and CEO of Kernel, to explore the cutting-edge world of browser infrastructure for AI agents. Catherine shares her journey from Cash App to founding Kernel, explaining how she discovered the critical need for scalable browser automation when AI agents need to interact with the web. The conversation dives deep into the technical innovations behind Kernel's use of unikernels and micro VMs, which enable blazingly fast browser startup times (20ms vs 30+ seconds) and unique snapshot/restore capabilities. Catherine discusses the evolution from deterministic browser automation to truly agentic behavior, the challenges of optimizing for variable web workloads, and her optimistic vision for an AI-powered future where the pie expands rather than consolidates. This episode is packed with technical insights about infrastructure, agent tooling, and the future of how software interfaces will evolve in an agent-native world. 0:24 Catherine's startup journey and founding Kernel1:30 Cash App's OpenAI experiment sparks the idea3:56 Why browser infrastructure for AI agents?6:36 Unikernels: 20ms startup vs 30+ seconds15:02 Optimizing for variable web workloads23:25 Future of agent-native software32:05 Hot takes!

  8. 9 فروری

    Coding agents need infra to apply code changes! (Chat with Tejas from Morph)

    Tim (Essence VC) and Ian (Keycard) sat down with Tejas Bhakta (CEO of Morph) to chat about building infrastructure for the fastest file edit APIs for coding agents. He shares how Morph delivers 10,000 tokens/second through speculative decoding, why cursor removed fast apply, and his vision for autonomous software that updates without prompts. The conversation covers subagent architecture, code search optimization, and the path to reliable AI coding at scale. Timestamps: 0:00 - Introduction0:29 - Why start Morph and pivoting through YC1:23 - The fast apply insight from Cursor3:42 - How fast apply works and speculative decoding6:09 - Use cases: when and where fast apply matters8:19 - Why Cursor removed fast apply9:22 - Morph's value prop beyond speed11:58 - Subagent architecture and SDK approach14:45 - Semantic search and code-specific tooling19:52 - Building custom coding agents vs platforms22:42 - Adoption inhibitors and the future of codegen23:26 - Spicy take: Autonomous software and reliability

سبھی دیکھیں (66)

کے بارے میں

The Infra Pod brings you insightful and thought-provoking discussions on the world of infrastructure software. This podcast is started by two engineers, Ian Livingstone (tech advisor for Snyk) and Tim Chen (General Partner at Essence VC), team up with a rotating cast of guests to dive deep into the latest trends and hot topics in the software infrastructure space.

معلومات

  • تخلیق کار
    The Infra Pod
  • فعال سال
    2023 - 2026
  • ایپی سوڈ
    66
  • درجہ بندی
    واضح
  • کاپی رائٹ
    © The Infra Pod
  • ویب سائٹ دکھائیں
    The Infra Pod

آپ کو بھی پسند آ سکتا ہے