The Video Signal

The Video Signal technical video digests

AI Code Review That Understands Your PR's Intent thumbnail

· 5:30

AI Code Review That Understands Your PR's Intent

As coding agents write thousands of lines and open numerous PRs, the bottleneck shifts from writing code to reviewing and trusting it. Tessl Code Review addresses this by providing automated review capabilities that are aware of the Pull Request's (PR) intent, not just the diff. Key features include customizable 'review lenses' scoped via `globs` for specific standards (e.g., security or random design), ensuring accountability remains with the human reviewer while automating consistency across an organization's codebase.

Key takeaways

  1. The Shift in Bottleneck 0:35

    With agents writing code at scale, manual review and establishing trust in agent-written code is now the primary bottleneck. Reviewing becomes the critical 'final gate' (00:00:35).

  2. Intent-Aware Review 0:55

    Tessl Code Review differentiates itself by reading the PR summary and title to understand the intended goal of the change, allowing it to review according to context rather than just line changes (00:00:55).

  3. Customizable Review Lenses 2:03

    Review lenses are customizable skills that can be evaluated and distributed across a repository. They can be precisely scoped using `globs` to target specific sections of the codebase (e.g., security or random design) (00:02:03).

  4. Owning the Standard 3:14

    The review standard is defined by a versionable configuration file within the repository itself, ensuring that the team owns and controls the rules rather than relying on external web UI settings or black boxes (00:03:14).

Watch on YouTube Full article

IBM’s mainframe chip collab, NVIDIA’s Poolside deal & Ox Alpha’s reveal thumbnail

· 30:59

IBM’s mainframe chip collab, NVIDIA’s Poolside deal & Ox Alpha’s reveal

The discussion covered major developments in AI infrastructure, focusing on IBM's new dual-architecture mainframe processor combining z/OS and Arm. This aims to bring modern AI workloads closer to mission-critical data residing on mainframes. Furthermore, NVIDIA's strategy was analyzed through its $6 billion deal with Poolside and the acquisition of Hugging Face, positioning NVIDIA as a central player in the open-source AI ecosystem by controlling key software standards. Finally, the reveal of Z.ai’s GLM-5.3-Flash model highlighted the trend toward stealth model releases.

Key takeaways

  1. IBM's Dual-Architecture Mainframe Processor 21:50

    IBM unveiled a new dual processor architecture at Hot Chips that combines IBM Z (mainframe workload) with Arm. This allows systems to run Arm-native Linux workloads alongside z/OS, addressing the challenge of integrating modern AI software into mission-critical mainframe environments.

  2. NVIDIA's Open Ecosystem Strategy 2:00

    NVIDIA is making a strategic play to be the center of open-source AI by acquiring Hugging Face (the cornerstone of open AI software) and securing a $6 billion license deal with Poolside. This solidifies their position in hardware while maintaining an open model ecosystem.

  3. LLM Model Release Tactics 24:30

    The anonymous 'Ox Alpha' model was revealed to be Z.ai’s GLM-5.3-Flash, an open-source LLM built with sparse and linear attention techniques. The discussion noted that stealth launches are a highly effective marketing strategy for generating hype and speculation.

Watch on YouTube Full article

AITX Austin Hackathon Winners Spotlight thumbnail

· 36:43

AITX Austin Hackathon Winners Spotlight

This technical spotlight details two winning autonomous agent applications from the AITX Hackathon: MasteryWrite and 8kEdu. Both projects demonstrate advanced capabilities beyond simple chat, focusing on taking real-world action in educational technology (EdTech). Key architectural takeaways include using specialized frameworks like NemoClaw/OpenShell to enforce policies around student PII data, implementing continuous self-improvement loops for assessment grading, and leveraging Visual Language Models (VLMs) to transform video lectures into interactive learning widgets.

Key takeaways

  1. MasteryWrite: Autonomous Assessment Engine 2:00

    This agent scores student essays against a rubric, explains its reasoning, and uses an autonomous evaluation loop to improve its own grading criteria over time. The system is designed to handle complex educational assessment while maintaining strict policies around student PII data.

  2. 8kEdu: Interactive Video Learning 5:05

    The agent transforms YouTube lectures into interactive learning experiences. Instead of relying on the entire transcript, it focuses on specific video frames (e.g., a matrix calculation) to generate editable widgets (charts, notebooks), allowing users to learn concepts from multiple sources and build recursive learning graphs.

  3. Local Model Deployment for Edge Cases 7:50

    The teams highlighted the utility of running models locally (e.g., using DGX Spark) to manage costs, ensure privacy, and run complex video-based inferences without constant reliance on external APIs.

Watch on YouTube Full article

How to Generate Mergeable Code with a Context Engine — Peter Werry, Unblocked thumbnail

· 18:36

How to Generate Mergeable Code with a Context Engine — Peter Werry, Unblocked

The presentation introduces the concept of a Context Engine designed to overcome limitations in current AI agents. Agents often suffer from 'satisfaction of search' and lack deep organizational context (intent, conventions, past decisions), behaving like new employees who reset their knowledge for every task. A Context Engine solves this by ingesting data from diverse sources—including GitHub PRs, Slack discussions, and architecture documents—to provide a comprehensive understanding that allows agents to generate accurate plans, show their work, and prevent compounding errors during complex development tasks.

Key takeaways

  1. The Context Problem in AI Agents 6:59

    Agents struggle because they lack access to 'unknown unknowns'—the critical organizational context like team conventions or architectural rationale. Simply attaching a wiki is insufficient; the agent needs guided, synthesized information.

  2. The Compounding Effect of Context 16:43

    The true value of a context engine is not in solving the first task, but in preventing compounding errors. Without proper context, agents may operate on wrong assumptions, forcing costly loops and significantly increasing time/token usage.

  3. The Role of Seniority Signals

    Advanced review agents can use signals like reviewer seniority or expertise to boost the visibility of important past comments, ensuring critical institutional knowledge is surfaced during code reviews.

Watch on YouTube Full article

AI models can now help run physical science experiments thumbnail

· 11:11

AI models can now help run physical science experiments

The Model Hardware Standard (MHS) is introduced as a novel framework enabling AI agents to safely and autonomously operate complex physical scientific equipment. This standard addresses the critical bottleneck in research—the time spent building and debugging experiments—by allowing large language models (LLMs), such as Claude, to interact with diverse hardware systems (e.g., microscopes, lab robotics) through standardized interfaces. Demonstrations show AI performing sophisticated tasks like image analysis, sample tracking, and closed-loop optimization in drug discovery, fundamentally accelerating scientific research.

Key takeaways

  1. Model Hardware Standard (MHS) 3:50

    MHS is a new standard developed by Anthropic to allow AI agents to communicate with and control physical equipment from various manufacturers, solving the problem of incompatible device languages. This enables general-purpose AI interaction with the physical world.

  2. Automated Experimentation 5:05

    AI can now run complex scientific experiments from scratch (e.g., operating a custom microscope) in minutes, tasks that previously required weeks of manual setup and debugging.

  3. Closed-Loop Optimization 9:00

    In pharmaceutical applications, AI can execute operations (e.g., aspirating samples), interpret the data (e.g., detecting bubbles), and automatically adjust parameters to improve the overall experiment in a closed loop.

Watch on YouTube Full article

Can LLMs Write Fast Multi-GPU Kernels? — Simran Arora, Together AI thumbnail

· 30:00

Can LLMs Write Fast Multi-GPU Kernels? — Simran Arora, Together AI

Multi-GPU AI workloads are increasingly bottlenecked by inter-node and intra-node communication links rather than individual GPU compute power. The speaker introduces ParallelKittens, a set of minimal primitives designed to simplify writing high-performance multi-GPU kernels. A benchmark called ParallelKernelBench tests whether frontier LLMs can generate optimized CUDA kernels for complex real-world patterns (e.g., data parallelism across tensor/expert dimensions). While models show promise in generating correct kernels, their ability to reason about critical architectural trade-offs—such as collective ordering, data partitioning, or choosing between transfer mechanisms (Copy Engine vs. TMA)—remains limited.

Key takeaways

  1. The Bottleneck Shift 17:04

    Improvements in compute (e.g., A100 to B200) have outpaced improvements in communication links (Intra-node: 3x; Inter-node: 2x). This forces the bottleneck off the individual GPU and onto the interconnects, causing standard PyTorch/NCCL baselines to fall below 50% of their communication-aware roofline.

  2. Kernel Development Simplification 2:20

    The speaker's team developed ParallelKittens, a small set of primitives that adds minimal lines to a single GPU kernel but enables state-of-the-art multi-GPU performance in production environments (e.g., Together AI).

  3. LLM Performance on Kernel Generation 20:40

    On the ParallelKernelBench, the best frontier models solved 28 out of 87 problems zero-shot. While scaling up attempts increased correctness to 36/87, the performance gain (speedup) plateaued near 31%. Failures are not syntax but stem from inability to reason about complex trade-offs.

Watch on YouTube Full article

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic thumbnail

· 26:11

How Anthropic Builds: Lessons from Labs — Mike Krieger, Anthropic

Mike Krieger discusses the evolution of building with AI models, emphasizing that ambition requires being 'unreasonable' in tool usage and process design. He details advanced development workflows—such as porting large codebases (e.g., Python to TypeScript) over a weekend using LLMs—and outlines modern organizational structures for research labs (like Anthropic's), which prioritize rapid iteration through 'persevere or pivot' cycles rather than rigid project management. Key technical shifts include moving from task delegation to expressing end-state goals, and utilizing advanced features like tagging for multi-agent, proactive code development.

Key takeaways

  1. Be Unreasonable in AI Usage 4:15

    The first generation of AI products often constrained access to tools and degrees of freedom. To maximize potential, users must be 'unreasonable' in their prompts, moving beyond simple task delegation to defining the desired end state.

  2. The Importance of Intent Over Code Lines 17:17

    In large codebases (e.g., 2,000 line PRs), the bottleneck is no longer review time but human comprehension. The trend is shifting toward sharing 'Claude code artifacts' that explicitly lay out intent, trade-offs, and rationale alongside the code.

  3. Labs Structure for Rapid Iteration 19:13

    Anthropic Labs operates on a two-week 'persevere or pivot' cycle. Teams are assembled around 'bets,' and the structure deliberately avoids tying people to specific projects, allowing for quick disbandment and reassembly.

  4. Scaling Requires Pre-Measurement 23:50

    Drawing from Instagram's scaling experience, it is crucial to pre-measure everything that might be needed (metrics) and implement thoughtful knobs and feature flags for dynamic runtime configuration.

Watch on YouTube Full article

The Agentic Commerce Stack — Ahnaf Prio, Best Buy thumbnail

· 20:38

The Agentic Commerce Stack — Ahnaf Prio, Best Buy

The talk outlines the architectural shift required for 'Agentic Commerce,' moving beyond brittle browser automation (like DOM reading or screenshotting) toward standardized protocols. The core solution involves defining specific primitives—such as MCP, A2A, ACP, UCP, and AP2—that allow AI agents to interact directly with merchant APIs without triggering fraud alarms. Successful implementation requires rigorous testing using behavioral and protocol compliance 'evals.'

Key takeaways

  1. Agentic Commerce Scope 2:08

    Approximately 45% of all agent sessions on major platforms (e.g., ChatGPT, Google Gemini) are related to shopping, indicating a massive market opportunity ($7B to $65B by 2030).

  2. Failure of Early Agents 5:08

    Early attempts using screenshots and reading the DOM were slow, clunky, and brittle. Furthermore, automated browser actions often trigger fraud alarms at the payment stage.

  3. The Need for Standardization 7:36

    To scale, commerce must standardize its primitives. Instead of relying on search catalogs, merchants should provide structured product feeds to protocols like ACP and UCP. The process involves the agent calling a merchant checkout API directly (no browser needed).

  4. Payment Mandates with AP2 16:41

    Autonomous payments require more than just tokens. AP2 (Agentic Payment Protocol) is an extension that mandates defining the authorizing party, a spend ceiling, and a revocation URL.

  5. Testing with Evals

    Building agentic commerce requires intense testing (evals) focused on behavior, protocol compliance, and latency benchmarks. Failure to test can lead to agents being misused in production (e.g., asking programming questions).

Watch on YouTube Full article

KV Cache-Aware Routing and P/D Disaggregation on Kubernetes — Yuchen Fama & Ashish Kamra, Red Hat thumbnail

· 21:48

KV Cache-Aware Routing and P/D Disaggregation on Kubernetes — Yuchen Fama & Ashish Kamra, Red Hat

This talk details advanced strategies for optimizing LLM inference in complex agentic workloads, moving beyond the limitations of steady-state public benchmarks. The focus is on two critical levers: KV Cache-Aware Routing and Prefill/Decode (P/D) Disaggregation. Implementing these techniques—using frameworks like LLMD—significantly improves latency and throughput by managing volatile cache usage and separating compute-bound prefill from memory-bandwidth-hungry decode phases, particularly in the middle concurrency band.

Key takeaways

  1. Agentic Workloads vs. Benchmarks 5:29

    Real-world agentic workloads exhibit chaotic multi-turn interactions (up to 3,000 turns) with high cache hit rates (>90%) and massive input/output ratios (often >100:1), which standard public benchmarks fail to capture [0:00], [3:29].

  2. KV Cache Routing Optimization 10:28

    Implementing KV cache-aware routing (via Endpoint Picker) is a cost-effective optimization, as the token cost difference between cached and uncached tokens can be as high as 10x [5:12]. This helps solve Time to First Token (TTFT) issues.

  3. P/D Disaggregation Benefits 15:28

    Separating prefill and decode into independent, scalable pods prevents 'phase interference'—where a long prefill stalls token generation (decode)—leading to drastically reduced P99 Inter Token Latency (ITL) from ~900ms down to ~100ms [9:28], [10:46].

  4. Prerequisites for PD 17:26

    Effective P/D disaggregation requires an advanced, high-speed network fabric like RDMA or RoCE to facilitate the transfer of KV caches between prefill and decode workers [10:46]. If such a fabric is unavailable, aggregated serving may be preferable.

Watch on YouTube Full article

LLM & AI Agent Benchmarks vs Reality: Why AI Applications Break thumbnail

· 15:01

LLM & AI Agent Benchmarks vs Reality: Why AI Applications Break

The performance of Large Language Models (LLMs) in real-world AI applications often deviates significantly from high benchmark scores. Building reliable AI systems requires balancing three critical factors—accuracy, latency/performance, and cost. Evaluation must therefore encompass both 'model evaluation' (assessing intelligence and accuracy) and 'system evaluation' (measuring scalability, throughput, and cost). For complex agents, this process extends to evaluating every step in the decision chain.

Key takeaways

  1. Benchmark vs. Reality Gap

    A high score on a leaderboard does not guarantee real-world performance; production environments test for latency, accuracy, and cost simultaneously.

  2. The Three Pillars of AI Design 2:05

    AI applications must balance Accuracy (correctness), Performance (response time/latency), and Cost. Optimizing for two often compromises the third.

  3. Agent Evaluation is Multi-Layered 11:20

    Evaluating agents requires checking every link in the decision chain, including system performance, formatting, safety/bias, factual accuracy, and domain-specific checks.

Watch on YouTube Full article

Ask the Experts: How NeMo Switchyard Helps Agents Select Models | Nemotron Labs thumbnail

· 49:23

Ask the Experts: How NeMo Switchyard Helps Agents Select Models | Nemotron Labs

NeMo Switchyard is an open-source model routing library designed for AI agents to solve the problem of relying on a single monolithic LLM. It automatically routes each agent query or step to the optimal model—selecting from any combination of local/cloud and open/closed models—based on real-time needs, optimizing for accuracy, cost, and latency. The system operates beyond simple request routing by tracking state across multi-turn agentic workflows, making it a critical component for building robust, efficient AI systems.

Key takeaways

  1. System of Models Approach 2:49

    The industry is moving away from the 'one model to rule them all' concept toward a 'system of models,' where multiple specialized models are used for different tasks, improving efficiency and capability (0:02:45).

  2. Agent-Aware Routing vs. Simple Routing 5:18

    Switchyard is more than a simple router; it operates on an agentic workflow, tracking state (e.g., tool calls, message history) across multi-turn sessions to make intelligent model selection decisions (0:04:25).

  3. Optimization and Learning 23:18

    The system treats model selection as an optimization problem. It can learn by analyzing agent traces and behavior, predicting potential errors or resource needs to route proactively and save tokens/time (0:21:58).

  4. Full-Stack Routing Flywheel 6:10

    The roadmap envisions a full 'flywheel' of routing, connecting model selection to inference optimization (via NVIDIA Dynamo) and data privacy/anonymization. This allows for continuous improvement across the entire agent lifecycle (0:06:10).

Watch on YouTube Full article

Build voice-first apps with Gemini 3.5 Transcribe thumbnail

· 1:44

Build voice-first apps with Gemini 3.5 Transcribe

Google launched Gemini 3.5 Transcribe, an advanced LLM-based model designed for building voice-first applications. This model is available via both the Interactions API and the Live API, offering fast, contextually accurate transcription of multi-speaker recordings. Key strengths include superior recognition of structured data like email addresses and phone numbers, as well as robust support for over 70 different languages.

Key takeaways

  1. Model Availability

    Gemini 3.5 Transcribe is available on both the Interactions API and the Live API.

  2. Structured Data Recognition

    The LLM-based model excels at transcribing alphanumerics, such as email addresses (e.g., thorwebdev@google.com) and recognizing correct US phone number formats.

  3. Multi-Language Support

    The model can recognize and transcribe over 70 different languages, even when language hints are set to English.

Watch on YouTube Full article

How to build with Gemini 3.5 Transcribe thumbnail

· 4:50

How to build with Gemini 3.5 Transcribe

Google DeepMind launched Gemini 3.5 Transcribe, an LLM-based transcription model available via both the Interactions API and the Live API. This model significantly enhances accuracy by correctly transcribing complex data types—such as email addresses, phone numbers, and mixed units of measurement—and maintaining high performance across over 85 supported languages, even when language codes are set to English.

Key takeaways

  1. LLM-Based Transcription Model

    The model's LLM foundation allows it to handle complex data structures and context better than traditional transcription models. For example, it can correctly identify and edit email addresses even if spoken phonetically (e.g., 'tosten at google.com').

  2. Handling Complex Data Types 2:00

    Gemini 3.5 Transcribe accurately recognizes specific formats, including US phone numbers and international variations (e.g., Singapore's 8-digit format). It can also correctly interpret units of measure (e.g., meters vs. centimeters).

  3. Multilingual and Customization Support 0:40

    The model supports over 85 languages, automatically recognizing spoken language even if language hints are set to English. Accuracy can be further improved by providing custom vocabulary (e.g., names of people in a meeting) or setting specific language codes.

Watch on YouTube Full article

The Death of Developer Advocates — Stephanie Jarmak, Sourcegraph thumbnail

· 18:16

The Death of Developer Advocates — Stephanie Jarmak, Sourcegraph

Developer Relations (DevRel) is evolving from focusing solely on human developers to incorporating AI agents as primary users and recommenders. The core strategy must shift toward Generative Engine Optimization (GEO), ensuring that product documentation and tooling are machine-readable, highly discoverable in registries (like MCP), and directly address specific pain points encountered by autonomous agents.

Key takeaways

  1. The Agent as a New User Persona 10:40

    Agents interact with tools by calling APIs, reading documentation, and recovering from errors. They represent a critical new user base that must be measured for friction points (e.g., burning an entire turn on a guessed parameter) to improve the developer experience.

  2. Measuring Agent Interaction and Friction 8:56

    Benchmarking tools, such as CodeScaleBench, must track agent traces with and without product tooling. This data reveals where agents fail or struggle, allowing teams to fix underlying tool interaction issues.

  3. Shifting Focus to GEO (Generative Engine Optimization) 12:22

    The goal of DevRel is moving from Search Engine Optimization (SEO) to Generative Engine Optimization (GEO). Content must be structured, authoritative, and designed for agents to quote accurately when recommending a product.

  4. DevRel as an Interdisciplinary Function 15:15

    The role of DevRel is no longer confined to one department; it requires collaboration across Engineering (building agent interfaces/evals), Product (owning the end-to-end agentic experience), and Marketing (managing content funnels for agents).

Watch on YouTube Full article

Accelerate agent improvement with LangSmith Engine thumbnail

· 3:25

Accelerate agent improvement with LangSmith Engine

LangSmith Engine automates agent improvement by analyzing large volumes of production traces (e.g., 20,000 traces). It identifies recurring issues—such as agents sending outreach to disqualified prospects without warning—and proactively proposes code changes and updated instructions. Furthermore, it automatically generates evaluation datasets from failing runs, allowing engineers to test proposed fixes against historical failures before deployment.

Key takeaways

  1. Automated Issue Identification

    Engine reviews production traces to surface recurring problems (e.g., agent outreach despite CRM flagging a prospect as disqualified), grouping related issues across multiple agent runs.

  2. Proposed Fixes and Instructions 2:05

    Beyond identifying the error, Engine drafts concrete changes: modifying tools (e.g., adding a 'confirmed disqualified' flag) and refining system prompts to include exceptions (e.g., requiring explicit confirmation before sending).

  3. Automated Evaluation Dataset Creation 2:40

    Engine handles the tedious process of growing evaluation datasets by formatting failing production runs into examples, including reference outputs detailing how the agent should have behaved.

Watch on YouTube Full article

🔬 The Physical World Is More Forgiving Than You Think — Anima Anandkumar, Caltech thumbnail

· 1:23:32

🔬 The Physical World Is More Forgiving Than You Think — Anima Anandkumar, Caltech

Anima Anandkumar discusses the paradigm shift of applying AI to physical science—moving beyond language models to model complex systems like weather and fusion reactors. The core technology is the Neural Operator (NO), which allows for accurate, high-speed simulation of continuous functions across multiple scales. Key advancements include using NOs with spherical geometry (e.g., FourCastNet 3) for long-term climate modeling and applying formal verification frameworks like TorchLean to ensure AI systems are robust in critical control loops.

Key takeaways

  1. AI for Science vs. Language Models 5:29

    The focus of advanced AI should shift from language processing to simulating the physical world (weather, materials, fusion). The challenge is that physical data is limited and requires incorporating fundamental laws into the model structure.

  2. Neural Operators for Weather Modeling 20:03

    Using Neural Operators allowed researchers to create models (like FourCastNet) that are not only accurate but also tens of thousands of times faster than traditional physics-based supercomputer simulations, democratizing complex modeling.

  3. Foundation Models for Physics 25:30

    By incorporating the spherical geometry of Earth and using NOs, models can perform long-term climate simulations (months/years) that fail when assuming a rectangular domain.

  4. Formal Verification with TorchLean 10:44

    TorchLean is an overall framework enabling the formal verification of neural networks themselves. This allows engineers to guarantee properties like certified robustness or bounds on outputs, which is critical for safety-critical control loops (e.g., nuclear reactors).

  5. Fusion Reactor Digital Twins 20:40

    NOs are used to create 'digital twins' of plasma evolution in fusion reactors (like the Tokamak), enabling simulations a million times faster than traditional methods and aiding in designing control systems to prevent disruptive events.

Watch on YouTube Full article

How AI Agents Let GTM Teams Scale — Justin Joyce, Cloudflare thumbnail

· 19:15

How AI Agents Let GTM Teams Scale — Justin Joyce, Cloudflare

Justin Joyce details how Cloudflare utilizes a three-pillar approach powered by AI agents to solve scaling issues in traditional Go-To-Market (GTM) operations. The core problem—that manual processes and knowledge gaps limit efficiency—is addressed by building self-service capabilities, automating data analysis, and proactively pushing insights to users. This framework allows non-technical staff to query complex data using 'skill files' and enables reps to access expert-level information via an internal agentic workspace (Cloudflare OS).

Key takeaways

  1. The GTM Scaling Problem 5:20

    Traditional GTM processes suffer from the 'context gap' (switching between different customer calls) and the 'expert gap' (inconsistent execution among reps), leading to significant inefficiency. Back-office teams often rely on manual work in Excel or limited dashboards, which fail to meet all operational needs.

  2. Pillar 1: Scaling Analysis via Skill Files 10:53

    To empower non-SQL users, the team built role-specific 'skill files.' These allow business users to ask questions of data directly and quickly, eliminating bottlenecks that previously required a dedicated data engineer. This capability is used both for back-office analysis and building GTM skills.

  3. Pillar 2: Scaling Insight (Pushing the Story) 15:00

    Instead of forcing users to search dashboards, insights are proactively delivered through synthetic weekly summaries. This is achieved by transforming data dimensions (time, manager, metric) and using a multi-agent workflow: a first draft agent, a second reviewer agent for veracity checks, and a third 'tone agent' that crafts the message, ensuring risks and opportunities are weighted equally.

  4. Pillar 3: Self-Service via Cloudflare OS 17:15

    The internal tool, Cloudflare OS, is an agentic workspace running on Workers and Durable Objects. It allows GTM teams to perform complex tasks—such as building QBR decks, account plans, or forecast briefs—by interacting with curated expert skills without needing manual intervention.

Watch on YouTube Full article

Knowledge Systems: The New GTM Stack — Jeffrey Wang, Exa thumbnail

· 18:49

Knowledge Systems: The New GTM Stack — Jeffrey Wang, Exa

Jeffrey Wang argues that Go-To-Market (GTM) strategy must be treated as an AI engineering problem. The core thesis is that GTM is fundamentally a data problem, requiring the creation of a 'live model of your world' that autonomous agents can act upon. He details systems like Exa (a search engine for agents), the ICP dashboard for classifying the Total Addressable Market (TAM), and Request Lens for real-time customer signal detection. Key architectural principles include making the system API-first, recognizing that consistent UIs still complement flexible chatbots, and prioritizing arbitrary customizability over rigid build vs. buy decisions.

Key takeaways

  1. GTM as a Data Problem 4:56

    The goal is to build a live model of the world—combining internal data (customer usage) with external data (web activity, company information)—that agents can programmatically act on. This shifts GTM from a purely sales function to an engineering challenge.

  2. Agent-First Requires API-First 16:59

    For any agent system (whether it's a GUI or a chatbot) to access data, the underlying systems must expose robust programmatic interfaces (APIs). This is critical for enabling agents to function.

  3. System Components: ICP Dashboard & Request Lens 8:38

    The ICP dashboard uses Exa's embeddings over the internet to classify every company in the TAM and estimate anticipated spend. Request Lens provides real-time alerts when significant customer signals occur (e.g., signups, search surges).

  4. The Value of AI Cloning (Jeffbot) 13:42

    An agent can be trained on historical data to mimic a user's professional style and decision-making. Jeffbot was built by analyzing 760 emails and hundreds of past decisions, creating 'evals' to calibrate its judgment against the founder’s own behavior.

Watch on YouTube Full article

The mathematics of AI uncertainty thumbnail

· 44:42

The mathematics of AI uncertainty

The discussion explores the critical role of quantifying uncertainty—a fundamental human trait often missing from current AI models—as key to building truly intelligent and reliable systems. Zoubin Ghahramani argues that for an AI system to make safe decisions in complex real-world scenarios (like self-driving cars or medical diagnosis), it must possess a sense of its own limitations, moving beyond mere 'correctness' to explicit measures of 'confidence.' The mathematical framework for achieving this is Bayesian inference, which allows systems to update beliefs and quantify uncertainty using evidence. Advances in fields like weather forecasting (GenCast) and protein folding (AlphaFold) demonstrate the power of incorporating probabilistic ensembles into deep learning architectures.

Key takeaways

  1. The Necessity of Uncertainty Quantification

    True intelligence requires a system that can represent, update, and utilize its own uncertainty to make decisions under limited perception. This is crucial for safety-critical applications like self-driving cars (0:00 - 7:45).

  2. Distinguishing Types of Uncertainty 12:05

    There are different types of uncertainty: aleatoric (inherent randomness, e.g., a pedestrian turning) and epistemic (uncertainty in the model's knowledge due to lack of data/experience, e.g., an unseen scenario). Systems must be able to differentiate these for appropriate decision-making (7:45 - 9:40).

  3. Bayesian Inference as a Model for Learning 16:10

    Bayes' rule provides a formal, mathematically rigorous way to update prior beliefs into posterior beliefs when new evidence is observed. This process models both human perception and continuous learning (16:10 - 23:00).

  4. Architectural Improvements for Reliability

    Modern AI systems, particularly LLMs, often lack explicit probabilistic representation of confidence; they are 'overconfident' when wrong. Incorporating uncertainty through techniques like ensemble forecasting (GenCast) or visualizing prediction variance (AlphaFold) is essential for building trustworthy AGI (35:00 - 42:00).

Watch on YouTube Full article

How We Got LLMs to Recommend Our Open Source Library — Christopher Burns, Inth thumbnail

· 16:27

How We Got LLMs to Recommend Our Open Source Library — Christopher Burns, Inth

The talk details how modern developer experience primitives must adapt for consumption by Large Language Models (LLMs) and autonomous agents. The core argument is that optimizing documentation requires moving beyond traditional SEO methods to focus on agent-facing artifacts. Key strategies include manually curating `LLMs.txt`, serving bundled markdown files, and ensuring the repository structure (`node_modules`) contains necessary context for coding agents.

Key takeaways

  1. Agent Inbound is the New Standard

    Inbound traffic sources are shifting from human discovery to LLMs (e.g., Claude, ChatGPT) recommending libraries like C15T. This requires optimizing for 'agent primitives' rather than just developer experience.

  2. Manual Optimization Beats Automation 9:52

    For critical files like `LLMs.txt`, manually writing the content is significantly more effective than generating it automatically; 'forty good lines beat a thousand lines of noise.'

  3. Bundling Context in Node Modules

    Coding agents rarely visit live documentation sites. To improve discoverability, developers should ship bundled markdown documents and an `AGENTS.md` file directly within the package's `node_modules` directory.

Watch on YouTube Full article