The Video Signal

The Video Signal technical video digests

OpenAI talks GPT-6 Astra and Millenium Prize, researchers create WeWorm exploit & IBM’s US Open app thumbnail

· 33:07

OpenAI talks GPT-6 Astra and Millenium Prize, researchers create WeWorm exploit & IBM’s US Open app

This episode reviews rapid advancements in AI, covering OpenAI's GPT-6 Astra model, its application in solving the Millennium Prize problem (Navier-Stokes), and the use of AI for complex tasks like 3D rendering and code generation. The discussion also details IBM's use of AI for personalized sports analytics at the US Open, including biomechanical limb tracking and real-time match forecasting. Finally, the segment warns about the increasing accessibility of advanced cyber threats, exemplified by the WeWorm exploit, which uses AI to discover zero-click vulnerabilities in messaging apps.

Key takeaways

  1. GPT-6 Astra and AI's Role in Solving Math Problems

    OpenAI introduced GPT-6 Astra, a model capable of state-of-the-art performance across computer use, software engineering, and cybersecurity. Astra reportedly solved the Navier-Stokes equation, a Millennium Prize problem, using 10,000 AI agents and requiring massive computational resources (estimated at $15 million worth of compute for a $1 million prize).

  2. IBM's AI for US Open Analytics 0:14

    IBM enhanced the US Open experience by implementing AI features, including pre-match likelihood forecasting (using classical ML models like boosted trees and logistic regression), real-time match probability tracking, and 'Serve Quality' metrics derived from tracking 21 points across a player's body at 50 frames per second.

  3. WeWorm: AI-Assisted Exploits 0:22

    A security firm used AI to discover a zero-click exploit (WeWorm) in WeChat's VoIP stack. This worm can autonomously spread and infect contacts simply by receiving a call, highlighting the growing threat of AI-assisted offensive security.

Watch on YouTube Full article

Seattle DGX Spark Hackathon Winners Spotlight thumbnail

· 40:58

Seattle DGX Spark Hackathon Winners Spotlight

This summary covers the NVIDIA DGX Spark Hackathon winners, spotlighting two advanced local AI applications: Kerberos, a shared spatial-awareness system for search-and-rescue (SAR) teams, and VELA, a voice-first, consent-controlled healthcare action system. Both projects demonstrate the power of running complex, multi-agent AI workflows entirely on local hardware (NVIDIA GB10), ensuring data privacy and real-time action capability.

Key takeaways

  1. Local AI for Privacy and Reliability 22:40

    Both winning systems (Kerberos and VELA) are designed to run entirely on the NVIDIA GB10, ensuring that sensitive data (e.g., medical records, live camera feeds) remains local and is not transmitted to the cloud, addressing critical security concerns in healthcare and SAR.

  2. Agentic Workflows for Complex Tasks 25:40

    The projects utilize multi-agent architectures (e.g., VELA's system) where specialized agents (like Parakeet for speech recognition, Neatron for reasoning, and Magpie for speech output) collaborate to perform complex, multi-step tasks, moving beyond simple chatbots to actionable outcomes.

  3. Shared Situational Awareness in SAR 3:40

    Kerberos creates a shared live map for SAR, integrating data from multiple sources (drones, robots, body cameras) to track responders, map searched areas, and pinpoint casualties or hazards, even indoors where GPS fails.

Watch on YouTube Full article

Training Agents 4: From reward functions to environments. thumbnail

· 1:13:40

Training Agents 4: From reward functions to environments.

This session details the evolution of agent training from simple functional reward signals to complex, stateful environments. The core concept is the `reset()/step()` contract, which allows agents to interact with a simulated world (the environment) over a sequence of actions. The discussion covers the OpenM framework, which standardizes environment definition, and its integration with TRL (Transformer Reinforcement Learning) using isolated compute environments like Hugging Face sandboxes. This enables training sophisticated agents, such as coding agents (OpenCode), on complex, multi-step tasks while maintaining reproducibility and isolation.

Key takeaways

  1. The Shift to Stateful Environments 1:42

    For agents performing sequences of actions (e.g., tool calls, file edits), the reward signal must come from the environment's state after an action, rather than being a simple Python function evaluated once. This requires adopting the standard `reset()/step()` contract, moving from sparse signals to continuous interaction loops.

  2. The OpenM Ecosystem 5:30

    OpenM provides a standardized, containerized way to define any task as an environment. It packages the task, the runtime (compute backend), and the grading components (verifiers, rewards) into a single, shareable unit that can be deployed on various platforms (e.g., Hugging Face Spaces, Kubernetes).

  3. Advanced Agentic Training Loops 9:10

    Training can be managed by two models: the 'White Box' (where the training framework owns the loop) and the 'Black Box' (where the agent/harness owns the loop). The latter requires a 'capture proxy' to intercept agent calls and send the resulting rollout graph back to the trainer for policy updates.

  4. Reproducibility and Isolation 7:30

    Environments are designed to be self-contained applications, often deployed in isolated compute environments (like HF sandboxes). This ensures that training runs are reproducible and prevents the agent from accessing or manipulating the verifiers or task description to 'hack' the reward signal.

Watch on YouTube Full article

Catch Agent Regressions Before You Ship: Evals for Managed Deep Agents thumbnail

· 8:57

Catch Agent Regressions Before You Ship: Evals for Managed Deep Agents

This session details how to implement robust evaluation (evals) for Managed Deep Agents to prevent performance regressions as the agent's capabilities grow. The process involves using Harbor, which ensures each evaluation runs in a fresh container. Evals are structured into an environment (data/state), a job (instruction), and a check (verifier). The workflow is scaffolded using `mda evals init`, which can be automated by handing the task to a coding agent (e.g., Claude Code). Results and traces are managed and monitored in LangSmith, allowing for continuous evaluation and integration into nightly CI pipelines.

Key takeaways

  1. Purpose of Evals

    Evals serve two primary goals: catching regressions (ensuring changes don't break existing features) and 'hill climbing' (actively improving agent capabilities). The focus is on defining and catching regressions.

  2. Harbor's Role in Evaluation

    Harbor is bundled into Managed Deep Agents and is crucial because it builds an image around the agent, ensuring every eval runs in a fresh container. It also manages test execution to prevent environment pollution.

  3. Anatomy of an Eval 2:15

    An evaluation consists of three parts: the environment (the starting data/state), the job (the instruction, defined in a markdown file), and the check (the verifier that determines if the job was completed adequately).

  4. Automating Eval Scaffolding 2:36

    The command `mda evals init` scaffolds the necessary files (e.g., `task.md`, `Dockerfile`, tests). Using the `-i` flag allows the work to be handed off to a coding agent, which generates the initial eval suite.

  5. Production Monitoring

    Evals can be managed in production by running them nightly within a CI system. Results are logged into LangSmith, allowing developers to continuously track agent performance and stability.

Watch on YouTube Full article

One Designer + AI. Hundreds of Deliverables. — Vincent Wendy, AI Engineer thumbnail

· 16:48

One Designer + AI. Hundreds of Deliverables. — Vincent Wendy, AI Engineer

This talk details how one designer managed the massive scale of deliverables (signage, stickers, landing pages, etc.) for a large conference (7,000 attendees, 140+ sponsors, 300+ speakers). The solution involves implementing a structured design system and automating workflows using AI agents (like Devin) and tools like Figma. The core methodology emphasizes shifting from manual, linear processes to highly automated, validated pipelines to solve the 'scale problem.'

Key takeaways

  1. The Five Pillars of Scaling Design 0:04

    To manage massive deliverables, the process must focus on: 1) Building a solid foundation (design system, typography, components); 2) Making designs reusable; 3) Automating workflows; 4) Validating output; and 5) Removing friction. (4:45)

  2. AI Agents for Automation 0:09

    AI agents (e.g., Devin) are used to automate complex tasks, such as generating speaker announcement graphics and trading cards for 300+ speakers, or pulling live schedule data and exporting it as PNGs. (9:16)

  3. Systemic QA and Validation 0:13

    AI can be used for visual quality assurance (QA), such as checking 140+ sponsor logos on a banner for missing assets or detecting visual inconsistencies on merchandise. (13:15)

  4. Thinking as a User 0:14

    The most critical shift is to think like an end-user (attendee) rather than a designer, focusing on handling exceptions and ensuring all elements (wayfinding, schedules) are interconnected. (14:21)

Watch on YouTube Full article

Generative UI... in Python? — Jeremiah Lowin, Prefect thumbnail

· 17:38

Generative UI... in Python? — Jeremiah Lowin, Prefect

This talk introduces Prefect, a Python DSL designed to solve the challenge of delivering rich, interactive UIs within the MCP (Messaging/Communication Protocol) ecosystem. While MCP apps allow tools to bypass the agent and render full HTML/CSS/JS interfaces, the primary user base (Python engineers in enterprises) needed a way to build these UIs without writing complex frontend code. Prefect achieves this by allowing developers to compose UIs using Python context managers and classes, which are then serialized into a JSON protocol and rendered by a React app. A key optimization is streaming the Python code itself over the wire and executing it in a sandbox, resulting in a 70% reduction in size compared to streaming the JSON representation.

Key takeaways

  1. MCP Apps and Agent Bypass

    MCP apps are an extension of the MCP protocol that allows tool results to bypass the agent and be delivered directly to the user as a full UI (HTML, CSS, JavaScript), enabling rich, interactive experiences.

  2. The Prefect Solution 9:03

    Prefect is a Python DSL that allows developers to compose UIs by nesting components using context managers, avoiding the need to write traditional frontend code.

  3. The Core Pipeline 10:37

    The process involves using a Python DSL to build a declarative representation, which is serialized into a JSON protocol. This JSON is then rendered by a React app hosted as the MCP app.

  4. Efficiency Improvement 16:40

    The system was optimized to stream the Python representation of the UI over the wire and execute it in a sandbox, which was found to be approximately 70% smaller and more efficient than streaming the full JSON protocol.

Watch on YouTube Full article

AAIF Reading Group - Prompt Injection as Role Confusion: Rethinking Agent Security thumbnail

· 55:36

AAIF Reading Group - Prompt Injection as Role Confusion: Rethinking Agent Security

This reading group explores Prompt Injection through the lens of 'Role Confusion,' arguing that the vulnerability stems from the model's inability to strictly isolate roles (User, System, Tool, Thought). Speakers detail advanced attack vectors, including forging chain-of-thought reasoning and exploiting model style, which significantly increases attack success rates (ASR). Mitigation strategies discussed include implementing instruction hierarchies, sandboxing environments, and ensuring robust access controls, particularly when dealing with smaller or less state-of-the-art (SOTA) models.

Key takeaways

  1. Role Confusion as the Core Vulnerability 18:20

    The core claim is that prompt injection is a problem of role confusion, where the model treats fabricated reasoning (e.g., forged chain-of-thought) as its own internal thought process, rather than recognizing it as external input. This allows attackers to mislead the model into following harmful instructions.

  2. Advanced Attack Vectors 20:00

    Attackers can increase ASR by injecting fabricated reasoning (forged thought) or by exploiting the model's style. One study showed that injecting forged chain-of-thought increased the ASR from 0% to 94% for OpenAI models.

  3. System-Level Security Risks 30:00

    Security risks extend beyond prompts to system components. Examples include exploiting API calls (e.g., Anthropic's Opus 4.8) by injecting encrypted tokens/signatures from a smaller model (Haiku), and supply chain attacks (e.g., the LightLM incident) where malicious packages are introduced via open-source frameworks.

  4. Mitigation through Design 38:20

    Proposed solutions include implementing 'instruction hierarchies' (prioritizing roles) and running models in isolated, sandboxed environments. The speakers emphasized that security must be baked into the design, not just added as a patch.

Watch on YouTube Full article

Training Taste — Thais Castello Branco, Taste Labs thumbnail

· 15:06

Training Taste — Thais Castello Branco, Taste Labs

Taste Labs addresses the problem of 'AI slop'—the homogenization and lack of context in AI-generated content—by proposing a shift in focus from model training to the application layer (inference time). The core methodology involves quantifying subjective domains like design by training 'probes' (small classifiers) on massive datasets (over 2 million websites). This approach allows for the measurement and prediction of slop, which is superior to traditional LLM-as-a-judge methods. Solutions include the 'Brand API' for structuring brand guidelines into machine-readable components and the 'Creativity API' for intentionally generating out-of-distribution content while respecting domain rules.

Key takeaways

  1. Defining Slop and Greatness 4:13

    Slop is defined by three characteristics: repetition, lack of fit (contextual incoherence), and low intent. While defining 'greatness' is subjective, defining slop is easier, as it represents a general sense of soullessness and convergence.

  2. Measuring Slop Quantitatively 5:46

    Taste Labs analyzed over 2 million websites from the past decade to understand design trends. They developed 'probes'—small classifiers—that extract objective features (e.g., contrast, alignment, palette) to predict slop, achieving higher accuracy than LLM-as-a-judge methods.

  3. Focusing on Inference Time 5:46

    The most critical intervention point is the application layer (inference time), where user context and intent are exchanged. Improving quality here is considered equally, if not more, important than improving the base model itself.

Watch on YouTube Full article

Design at the Speed of Adjectives — Paul Bakaus, Renaissance Geek, Inc. thumbnail

· 15:59

Design at the Speed of Adjectives — Paul Bakaus, Renaissance Geek, Inc.

The talk introduces 'Impeccable,' a design skill designed to enhance coding harnesses (like Copilot and Claude Code) by providing a vocabulary to steer AI-generated design. The core thesis is that good design cannot be 'oneshot' or fully automated because it is context-rich, iterative, and requires human decision-making. Instead of automating the process, Impeccable allows users to inject specific adjectives and verbs (e.g., 'bolder,' 'quieter,' 'distill,' 'harden') to guide the AI toward specific design goals, thereby improving the quality of the human-AI collaboration.

Key takeaways

  1. Design is not a one-shot process 9:58

    Good design must be context-rich and iterative. The speaker argues that fully automating design is currently impossible, as human judgment is required to define the emotional territory and audience.

  2. Impeccable facilitates steering, not abdication 13:50

    The tool's purpose is to give users the necessary control to steer the agent using specific design vocabulary. The speaker explicitly rejects the idea of an automatic mode, stating that the point is guiding the process, not letting the AI do all the work.

  3. The traditional design handoff is collapsing 4:16

    The traditional 'waterfall' process (PM $ ightarrow$ Design $ ightarrow$ Engineer) is rapidly breaking down, leading to a blurring of roles where engineers and designers must increasingly work in shared, fluid processes.

Watch on YouTube Full article

Baz, Docker & Meta on Verifying Agent Code thumbnail

· 10:14

Baz, Docker & Meta on Verifying Agent Code

The session discusses the critical limitation of current AI coding agents: while they excel at generating code, they often fail at verifying that the code meets complex specifications. Speakers from Baz, Docker, Meta, and Christopher Batey presented advanced strategies—such as using real systems as test oracles, implementing anti-test slop initiatives, and elevating human review to Architectural Decision Records (ADRs)—to ensure reliability and maintain system integrity when integrating AI-generated code.

Key takeaways

  1. Verification is the Hard Part

    The primary challenge with coding agents is not writing code, but proving that the generated code accurately implements the required specification. Agents are optimized for feature generation, not full spec extraction or verification.

  2. Specifying Bugs, Not Features

    Baz demonstrated that providing explicit evidence of a bug (e.g., a screen recording of an overlapping button) is far more effective than general specs, as agents may fail to replicate specific, subtle behavioral constraints.

  3. Test Oracles Over 100% Coverage

    Attempting to achieve 100% test coverage is inefficient. Instead, pointing tests at a real, stable system (a 'test oracle,' like S3) and running a limited set of critical tests can effectively lock down behavior and validate system interactions.

  4. Anti Test Slop Initiative

    Meta implemented an anti test slop initiative, using a separate AI tool to judge the quality and necessity of AI-generated tests, thereby reducing CI overhead from useless or redundant tests.

  5. Elevating Human Review to ADRs

    When reviewing large pull requests (e.g., 7,000 lines), human review must move earlier into the process. Architectural Decision Records (ADRs) should capture system-level decisions, allowing agents to check implementations against a structured, human-reviewed architectural baseline.

Watch on YouTube Full article

Score Every Production Trace with an LLM Judge, from Your Terminal (LangSmith CLI) thumbnail

· 5:08

Score Every Production Trace with an LLM Judge, from Your Terminal (LangSmith CLI)

This walkthrough demonstrates how to implement automated, large-scale evaluation of AI agents using an LLM-as-a-judge within LangSmith. By setting up an online evaluation, developers can programmatically score incoming chat traces (e.g., checking for user frustration) without manually reviewing thousands of interactions. The process involves using a coding agent to install LangSmith skills and configure the evaluation, followed by managing the sampling rate to control costs.

Key takeaways

  1. Online LLM-as-a-Judge Setup

    Online evaluations allow an LLM to automatically score incoming agent traces based on a defined prompt and rubric (e.g., detecting user frustration). The output is a score and reasoning attached directly to the trace.

  2. Using LangSmith CLI for Automation 0:01

    A coding agent can be instructed to use the LangSmith CLI to create and manage the LLM judge evaluator, automating the setup process.

  3. Cost Management via Sampling Rate 0:04

    The sampling rate can be updated (e.g., from 100% to 50%) to reduce evaluation costs while maintaining continuous monitoring.

Watch on YouTube Full article

The Race to Done: Fable 5.1 vs GPT-6 Astra. Who Wins? thumbnail

· 16:21

The Race to Done: Fable 5.1 vs GPT-6 Astra. Who Wins?

This video compares the capabilities of Claude Fable 5.1 and GPT-6 Astra by having both models build a native Mac clipboard manager from the same initial prompt. The speaker argues that the true measure of a model's utility is not its initial benchmark performance, but its ability to successfully iterate and refine the build through subsequent, detailed prompting. Astra was preferred due to its speed of iteration, lower token usage, and ease of implementing complex functional changes, such as hotkey adjustments and confirmation messages.

Key takeaways

  1. Iteration is the ultimate test of AI utility

    The most critical skill is knowing how to refine and improve a model's initial output (the 'second round of prompting'), rather than relying solely on the initial prompt response.

  2. Model design differences reveal user needs 3:31

    Comparing two models on the same task (e.g., Fable's narrow list view 'Ledge' vs. Astra's wide card view 'Shelf') helps the user discover design preferences they hadn't consciously decided upon.

  3. Speed of iteration impacts quality 10:06

    The speaker found that Astra's ability to process multiple changes (1.0, 1.1, 1.2) in the time it took Fable to complete version 1.0 allowed for more comprehensive refinement and higher quality output.

Watch on YouTube Full article

Tessl Code Review: Catching 74% of Bugs Pre-Merge thumbnail

· 25:56

Tessl Code Review: Catching 74% of Bugs Pre-Merge

Tessl Code Review is an AI-native code reviewer designed to address the critical bottleneck of trusting code generated by coding agents in a software factory. It functions as an automated GitHub app that runs specialized, customizable review rules (lenses) against Pull Requests (PRs). The system emphasizes self-improvement loops, allowing the review process to learn from the codebase and the team's specific best practices, thereby increasing defect detection rates (claiming up to 74% detection).

Key takeaways

  1. AI Code Review and the Software Factory 5:56

    Building a 'software factory' requires more than just plumbing; it requires self-improvement loops that continuously refine the context and skills used by coding agents. Code review is positioned as a critical loop that feeds back into the factory to improve code quality before merging.

  2. Customization via Lenses and Globs 22:07

    The system uses customizable 'lenses' (review rules) that can be tuned to specific domains (e.g., audio DSP) and restricted to specific file paths using globs. This allows for highly targeted reviews, even in large mono-repos.

  3. Local and CI Integration 23:50

    Tessl Code Review can be run directly via the CLI (`Tessl code review give it the profile`) against local changes, enabling developers to catch defects before opening a PR, complementing its automated GitHub app integration.

Watch on YouTube Full article

Workshop: Building and optimizing dictation features thumbnail

· 36:06

Workshop: Building and optimizing dictation features

This workshop details the architecture for building low-latency dictation features using AssemblyAI's APIs. The core strategy involves leveraging the Sync API—a single POST request—to achieve speed superior to traditional async or streaming methods. The process is optimized through three key stages: using key terms prompting for accuracy, implementing connection warming to minimize network overhead (DNS, TCP, TLS), and running a cleanup pass via LLM Gateway (e.g., Qwen3.5 4B Fast) to refine raw transcripts into polished, intent-preserving text. The goal is to deliver results on screen in under one second.

Key takeaways

  1. Sync API Preference 5:35

    The Sync API is preferred for dictation because it avoids the overhead of maintaining a WebSocket connection (streaming) and bypasses the inherent latency floor of traditional async endpoints, which is unsuitable for short, burst dictation sessions.

  2. Latency Optimization via Warming 11:40

    To minimize latency, it is critical to call a warm endpoint (`client.sync.warm`) while the user is recording. This pre-pays the networking costs (DNS, TCP, TLS handshake), ensuring the subsequent transcription request goes straight to inference.

  3. Cleanup Pass with LLM Gateway 18:20

    A cleanup step using an LLM (like Qwen3.5 4B Fast) is necessary to transform raw, spoken text (e.g., 'I think we should meet in 5 minutes') into polished, corrected text while preserving the original intent. This is achieved by prompting the model to act as a function in a pipeline, not an assistant.

  4. Upcoming Dictation API 30:00

    AssemblyAI is rolling out a dedicated Dictation API (`client.dictation.describe`) that will wrap the entire loop (STT + Cleanup) into a single, simplified call, making the process easier for developers.

Watch on YouTube Full article

Can AI help us better predict the weather? thumbnail

· 44:25

Can AI help us better predict the weather?

Google DeepMind's research demonstrates how AI is fundamentally transforming global weather forecasting by moving beyond traditional Numerical Weather Prediction (NWP). The latest model, WeatherNext 3, is notable for taking raw satellite imagery and predicting raw station observations in a single, end-to-end architecture. The discussion highlights the shift from deterministic single-point forecasts to probabilistic forecasting, which provides a range of possible scenarios crucial for managing extreme events and informing critical infrastructure decisions like energy load forecasting and disaster preparedness.

Key takeaways

  1. AI's Advantage in Forecasting 23:33

    AI models learn statistical patterns from historical weather data, allowing them to capture large-scale structures (e.g., across an entire hurricane) that traditional, localized NWP models might miss. This ability to process global structure improves accuracy, especially for complex events.

  2. WeatherNext 3 Architecture 43:20

    WeatherNext 3 represents a significant architectural leap by taking raw satellite imagery and predicting raw station observations simultaneously, consolidating multiple traditional stages into a single, highly accurate model.

  3. Probabilistic Forecasting 35:55

    Modern AI models generate multiple possible future scenarios (spaghetti plots) rather than a single deterministic guess. This probabilistic approach is vital for decision-making during extreme or rare events, allowing forecasters to quantify uncertainty.

  4. Hurricane Melissa Case Study 0:38

    The model's ability to predict the rapid intensification and specific trajectory of Hurricane Melissa, providing critical lead time (3+ days) for evacuation and preparation, demonstrated the operational value of the AI system.

  5. Impact on Critical Systems

    Beyond general weather, the model can predict specific variables like wind, solar, and temperature with high resolution, enabling better predictions for electrical load forecasting and agricultural planning.

Watch on YouTube Full article

Meta, Stanford & Odevo on Agentic Coding at Scale thumbnail

· 10:10

Meta, Stanford & Odevo on Agentic Coding at Scale

The session explores scaling agentic coding adoption from a single team to hundreds of engineers. Key findings highlight that while AI tooling can drive massive organic community growth (e.g., Meta reaching 80%+ weekly usage), success is highly dependent on organizational maturity. Speakers warn that deploying agents into an organization with weak software delivery practices will worsen outcomes, emphasizing that foundational improvements—such as robust CI/CD pipelines, dedicated platforms, comprehensive testing, and established coding standards—must precede advanced AI adoption.

Key takeaways

  1. Meta's Adoption Strategy 1:19

    Meta grew an organic community from ad hoc usage to over 40 times its original size. Weekly tool usage increased from under half to above 80%, demonstrating that sustained adoption can be achieved without mandatory enforcement. (00:01:39)

  2. Performance Spread and the 10x Engineer 2:47

    Studies across 150,000 engineers show the widest performance spread ever measured. Contrary to initial hypotheses, top performance is now being achieved by individuals skilled in creating and utilizing agents. (00:02:47)

  3. Prerequisites for Agentic Coding 5:11

    The 2025 DORA report warns that pointing agents at an organization already struggling with software delivery will make things worse. Successful adoption requires fixing fundamentals first: CI/CD, a platform, tests, and coding standards. (00:05:1)

Watch on YouTube Full article

The Universal Remote Control for AI — Alex Hancock, Block thumbnail

· 11:01

The Universal Remote Control for AI — Alex Hancock, Block

The talk addresses the lack of a standardized client-to-harness interface in the agentic AI stack. While the Model Context Protocol (MCP) provides a strong standard for agents performing actions (the agent going out), a standard for client software to issue tasks and receive updates is missing, leading to bespoke, non-interoperable systems. The speaker proposes the Agent Client Protocol (ACP), developed by the Zed and JetBrains teams, which standardizes communication using JSON RPC. ACP allows multiple, independent client applications (e.g., editors, terminal clients) to drive the same agent harness, significantly increasing interoperability and enabling the modular placement of the four core components: client, harness, tools, and model, especially when remote transports are implemented.

Key takeaways

  1. The Need for Client Standardization 2:03

    Currently, many agent harnesses expose custom or bespoke interfaces, often requiring a single, dedicated client application. This lack of a universal standard hinders interoperability, comparing it to needing a different browser for every website.

  2. ACP as the Universal Remote Control 5:02

    The Agent Client Protocol (ACP) was developed to allow a single, high-quality client implementation (like an editor) to control any harness, regardless of the underlying system. It is designed to be neutral and extensible.

  3. Modular Agentic Stack Architecture

    By implementing remote transports for ACP, MCP, and model endpoints, the entire agentic stack becomes modular. The client, harness, tools, and model can all be independently placed (e.g., client on a desktop, harness in a container, model in the cloud).

Watch on YouTube Full article

MCP Apps: Give the Model Data, Give the User a UI — Dustin Mihalik, Indeed thumbnail

· 15:34

MCP Apps: Give the Model Data, Give the User a UI — Dustin Mihalik, Indeed

This talk details the architectural challenges of building Model-Composable Platform (MCP) applications for large language models (LLMs) like Claude and ChatGPT. The core thesis is that for a UI widget to function effectively, it must be treated as a data layer, not just a visual display. The speaker outlines three critical rules for developers: all displayed information must be provided as data to the model; the tool description must explicitly state that a UI exists; and, most importantly, data processing must be strictly separated from UI rendering to maintain model context and reasoning capability.

Key takeaways

  1. Data-First Design Principle

    When building MCP apps, developers must focus on defining the data the model needs to process before considering the UI. The UI should be viewed as a side effect or result of the model exploring the underlying data.

  2. Rule 1: Show the Model Everything 5:13

    Any information displayed to the user via the UI must also be provided as structured data to the model. Failing to do so creates a 'black box' that prevents the model from answering follow-up questions about the displayed content.

  3. Rule 2: Declare the UI in the Description 8:26

    The tool description must explicitly state that a UI exists. Otherwise, the model will attempt to narrate the results underneath the widget, leading to redundant and confusing output.

  4. Rule 3: Separate Data Processing from UI Rendering 13:39

    This rule supersedes the others. The architecture must split the job into two distinct tools: one for pure data retrieval (e.g., `search_jobs`) and a separate, dedicated tool for rendering the results (e.g., `render_jobs`). This allows the model to perform complex data exploration without being limited by the UI's single call.

Watch on YouTube Full article

Accelerate the self-improving AI loop with CoreWeave ARIA thumbnail

· 8:44

Accelerate the self-improving AI loop with CoreWeave ARIA

CoreWeave ARIA is an AI research and iteration agent integrated into Weights & Biases (W&B) designed to accelerate the self-improving AI loop. It addresses common challenges in AI development, such as stalled iteration cycles, massive data volume analysis, and manual dashboard creation. ARIA automates auto-research, analyzes training metrics and agent traces, generates comprehensive reports with suggested next steps, and assists in optimizing LLM prompts and agent performance.

Key takeaways

  1. Automated Auto-Research Loop

    ARIA can conduct auto-research by analyzing recorded training metrics and agent traces to uncover hidden insights. It generates visualization-packed W&B reports and automatically launches follow-up training experiments based on its findings, minimizing manual effort (5:51).

  2. Agent Performance Optimization

    ARIA supports agent development by analyzing production traces and suggesting improvements. It can specifically help refine system prompts and evaluate multiple prompt alternatives using defined datasets to achieve higher quality results at lower latency (7:07).

  3. Comprehensive Workflow Support 2:30

    Beyond research, ARIA handles time-consuming manual tasks like providing advice, generating code, and executing commands, all while supporting concurrent conversations that can continue running in the cloud (2:21).

Watch on YouTube Full article

How long can your skills be before your agent forgets what you told it? — Laurie Voss, Arize AI thumbnail

· 22:26

How long can your skills be before your agent forgets what you told it? — Laurie Voss, Arize AI

The capacity of frontier LLMs to follow complex instructions has increased by an estimated tenfold in the last year, moving the instruction ceiling from 200-300 rules to 2,000 to 5,000 rules. This shift fundamentally changes prompt engineering from a 'compression problem' (fitting rules into a small budget) to a 'verification problem' (confirming the model actually obeyed the rules). Developers must now focus on robust output validation (evals) rather than worrying about the length of the skills file.

Key takeaways

  1. Instruction Ceiling Increased by 10x 10:12

    A year ago, models struggled with 200 to 300 instructions. Current frontier models can handle up to 2,000 instructions, with the best models reaching 5,000 rules (6:12).

  2. Failure Mode Shift: From Forgetting to Refusing 20:00

    Models no longer fail by simply forgetting instructions. Failure modes are now diverse: Deepseek V4 Pro forgets; Claude Opus 4.7 refuses at the API level due to safety classifiers; Gemini 3.1 Pro runs out of thinking tokens; and GPT 5.5 writes a partial report and politely states the request is 'stupid' (12:00).

  3. Engineering Focus Shifts to Verification

    The challenge is no longer fitting rules into a small prompt (compression); it is verifying that the model actually followed all instructions, which requires external output checking (an eval) (14:00).

Watch on YouTube Full article