The Video Signal

The Video Signal technical video digests

Building GTM AI Agents: Lessons from Deploying to 6,000 Users — Sait Izmit, Snowflake thumbnail

· 20:39

Building GTM AI Agents: Lessons from Deploying to 6,000 Users — Sait Izmit, Snowflake

This talk details the process of building and scaling an internal Go-To-Market (GTM) AI assistant using Snowflake Co-work. The speaker emphasizes that successful deployment hinges less on technological capability and more on strategic execution: prioritizing quality over coverage, managing user trust, and planning for continuous architectural evolution. The system has processed over one million questions for 6,000 users, evolving from simple agent instructions to a complex architecture involving semantic views, skills, and MCP connections.

Key takeaways

  1. Quality Over Coverage 6:56

    Focusing on high accuracy (e.g., 95% correct) for a smaller set of critical questions is more effective than attempting to cover all possible data points with lower accuracy, as the first few interactions build user trust.

  2. Phased Rollout and Activation 9:06

    AI tools must follow a controlled launch process: Pilot (proving accuracy), Beta (e.g., 10% of users, tracking >70% retention rate), and General Availability (GA). The biggest failure point is often activation and change management, not the technology itself.

  3. Addressing the Collapsing Wow Factor 14:16

    After initial novelty wears off, the roadmap must evolve beyond simple Q&A. The progression should move from 'Talk to your data' (democratization) to 'Automate workflows' (integrations/MCPs), then to 'Team building skills,' and finally 'Hyper-personalization.'

Watch on YouTube Full article

Agents Aren't Taking Your Jobs. They're Creating More Work Instead. thumbnail

· 31:14

Agents Aren't Taking Your Jobs. They're Creating More Work Instead.

AI agents are generating significantly more work for humans—an 'agent management tax'—rather than eliminating it. The complexity of managing these agents scales dramatically from individual use to enterprise deployment. While verifiable domains (like legal or coding) show rapid adoption due to clear success criteria, small businesses often struggle with limited capital and resources. Enterprises gain a significant advantage by having dedicated teams for agent governance, security, and deep integration, which is necessary to manage the increased complexity.

Key takeaways

  1. Agents create work, they don't eliminate it

    The common assumption that agents will reduce headcount is incorrect. Data shows agent token usage is increasing rapidly (e.g., 14-fold between February and August on Open Router), with agents burning more than five tokens for every one a human burns. This necessitates new management roles.

  2. The role shifts to 'Above the Loop' 20:00

    As agents improve, the human job is shifting from execution to oversight: deciding what runs, providing context/permissions, checking results, and intervening when failure occurs. This requires domain knowledge (e.g., legal expertise) to validate outcomes.

  3. Enterprise advantage lies in capital and structure 24:19

    Enterprises report better returns because they can afford dedicated teams (security, quality control, product management) to handle the complex setup, monitoring, and integration required for agent deployment. This deep investment is necessary for scaling.

  4. SMBs must focus on verifiable domains 28:20

    Small businesses struggle when agents are used in non-verifiable domains (e.g., general business operations). Success requires finding processes they already perform manually and letting the agent handle only the preparatory steps.

Watch on YouTube Full article

Cisco & Stanford on Why Skills Are the New Code thumbnail

· 9:44

Cisco & Stanford on Why Skills Are the New Code

The industry is shifting from viewing software development around explicit code and implementation toward one centered on high-level intent and 'skills.' This paradigm requires a layered agent stack (models, tools, context, harnesses) that must be managed rigorously. Experts highlight that skill sprawl leads to failure through overlap, drift, and lack of activation visibility. Crucially, the consensus is that achieving business value relies less on deploying increasingly powerful frontier models and more on sophisticated context engineering and centralized management of skills.

Key takeaways

  1. Skills as the New Code Paradigm 0:14

    Software development is transforming from revolving around code/implementation to revolving around intent and instructions. Skills must be treated as first-class citizens, not just configuration files (Guy Podjarny).

  2. Three Failure Modes of Skill Sprawl 3:29

    Skill sprawl negatively impacts teams through: 1) Overlap (multiple isolated implementations achieving the same outcome); 2) Drift (teams using outdated versions of skills); and 3) Lack of Activation (no visibility into whether a skill is actually being used by agents or humans).

  3. Context Engineering Beats Model Size 6:59

    For achieving business value, smarter context engineering is more critical than deploying the most advanced model. Mid-tier models (e.g., Sonnet, GPT medium reasoning) are often sufficient when provided with proper context and structured skills.

  4. Instruction Following Leakage 8:48

    Empirical testing involving 500 skills across 1,000 tasks revealed that over half (55%) of the time, models followed a skill's instructions even when the skill was not loaded. This suggests valuable information is already encoded in model weights.

Watch on YouTube Full article

Who’s afraid of an open-weight model? GLM, context bombing and post-Black Hat attacks thumbnail

· 26:43

Who’s afraid of an open-weight model? GLM, context bombing and post-Black Hat attacks

The discussion explores the rapid advancement and associated risks of open-weight AI models like GLM-5.3, which show strong capabilities in vulnerability discovery and validation. Defensively, researchers developed 'context bombing,' a technique using malicious prompts to shut down attacking AI agents. The conversation emphasizes that while offensive security (AI model development) is accelerating faster than defensive measures (automated patching/blue team), classic principles like defense-in-depth and assuming breach remain critical. Finally, the segment warns against sophisticated social engineering attacks targeting cybersecurity professionals post-conference.

Key takeaways

  1. AI Vulnerability Discovery is Accelerating 2:00

    Open-weight models like GLM-5.3 demonstrate advanced cyber capabilities through post-training, achieving a score of 84.5% on CyberGym for vulnerability discovery and validation, reaching parity with competitors like GPT Sol and Mythos.

  2. Context Bombing as Defensive Measure 12:10

    Tracebit researchers developed 'context bombing,' which uses malicious prompts placed alongside assets to confuse attacking AI agents. Testing showed that instances of models proceeding with an attack dropped from 91% to 15%.

  3. Blue Team Must Match Offensive Pace 4:00

    Experts stressed the need for significant investment in automated patching and blue team capabilities (e.g., automated SOC) to keep pace with AI-driven offensive security, noting that manual processes are insufficient.

Watch on YouTube Full article

The Missing Layer in Agentic AI — Giedrius Šteimantas, Oxylabs thumbnail

· 15:04

The Missing Layer in Agentic AI — Giedrius Šteimantas, Oxylabs

The video addresses a critical gap in agentic AI: the lack of robust infrastructure for interacting with the open web. The speaker argues that relying solely on large language models (LLMs) or general browser automation is inefficient, expensive, and unreliable. By applying principles from professional web scraping—specifically prioritizing cost control, validating content before processing, and using a browser only when absolutely necessary—the agent's performance can be dramatically improved across all stages of the purchase workflow.

Key takeaways

  1. The Core Problem in Agentic AI 13:55

    Many agents fail or waste resources because they assume an HTTP 200 status code means valid content. Feeding LLMs large HTML blocks containing CAPTCHAs or non-product data leads to wasted tokens (e.g., wasting 70% of tokens when only three out of ten pages are valid).

  2. Discovery Stage Optimization 9:50

    Instead of using a browser with a predefined list of retailers, the agent should use a dedicated search API. This approach returns compact JSON (<2,000 tokens), is fast (<700ms), and allows the agent to fan out queries across many popular search engines.

  3. Decision Stage Optimization

    The decision stage can be optimized by replacing browser scraping with a dedicated scraper API. This ensures only valid content is returned, fails loudly (with explicit errors on blocks), supports markdown, and allows parallel requests while billing only for successful results ('No cure, no pay').

  4. Checkout Stage Enhancement

    Since the checkout process requires highly dynamic interaction, a browser is necessary. The solution involves hardening the agent using Playwright MCP combined with an Oxylabs headless browser that provides stealth, residential proxy support, and geolocation capabilities.

Watch on YouTube Full article

Don't Build Agents, Build Environments Instead thumbnail

· 27:19

Don't Build Agents, Build Environments Instead

The talk argues that the most critical challenge in building agentic workflows is not the agent itself, but the underlying environment (the 'background part'). Teams should focus on 'environmental engineering'—designing robust, fast, and persistent development environments ('dev boxes') rather than optimizing the agents. Key architectural shifts involve treating sessions as long-running, stateful processes that require sophisticated isolation between the control plane (planning) and the data plane (execution).

Key takeaways

  1. Focus on Environments, Not Agents

    The difficulty in background agent systems lies in the environment they operate within. The focus should be on building reliable 'dev boxes' that provide necessary resources beyond a bare sandbox.

  2. Jobs vs. Sessions 20:04

    Traditional CI/CD treats runs as stateless 'jobs.' Agents require long-running, resumable 'sessions' that must persist state (e.g., file system snapshots) and potentially outlive the initial machine runtime.

  3. Dev Boxes vs. Sandboxes 3:58

    A sandbox is bare; a 'dev box' must be rich enough to handle complex tasks (e.g., running local servers, taking screenshots, profiling on GPUs), requiring more than just basic Linux access.

  4. Architectural Separation 24:16

    To prevent failure, the system must separate the agent's planning logic (Control Plane) from the risky execution tools (Data Plane). The agent should issue remote calls to a dedicated sandbox rather than running tools collocated with its own process.

Watch on YouTube Full article

Einstein Arena: Harnessing Collective Agent Intelligence for Open Science — James Zou, Together AI thumbnail

· 16:56

Einstein Arena: Harnessing Collective Agent Intelligence for Open Science — James Zou, Together AI

The presentation advocates for a paradigm shift in AI agent development: moving from designing restrictive 'workflows' to building flexible 'environments.' These environments provide infrastructure, incentives, and guardrails (like the Einstein Arena and DSGym) that allow agents to collaborate and compete on open-ended problems, leading to emergent collective intelligence and solving complex scientific and computational challenges.

Key takeaways

  1. Environment Design vs. Workflow Design

    The core thesis is that specifying *where* an agent works (the environment) is superior to telling it *how* to work (the workflow), as environments enable greater creativity and intelligence emergence.

  2. Einstein Arena: Open Scientific Collaboration 0:05

    This platform allows agents to collaborate on open-ended scientific problems, featuring curated problems, a deterministic verifier, a discussion forum, and a live leaderboard. Agents achieved new solutions for the kissing number problem in 11 dimensions (reaching 604 spheres) through collaboration.

  3. DSGym: Data Science Evaluation Environment 0:11

    DSGym is a unified environment for evaluating and training data science agents, featuring curated tasks across diverse domains (biology, physics, economics). It addresses the vulnerability of existing benchmarks to 'shortcuts' by requiring execution-verified trajectories.

Watch on YouTube Full article

⏭️ Forward Deployed: Voice AI on what works in 2026 thumbnail

· 36:31

⏭️ Forward Deployed: Voice AI on what works in 2026

The discussion explores the advanced engineering challenges of deploying real-time voice AI agents in enterprise settings. Speakers emphasize that achieving human-like performance requires complex, multi-stage cascaded pipelines (Speech-to-Text $\rightarrow$ LLM $\rightarrow$ Text-to-Speech), rather than simple end-to-end Voice-to-Voice models. Key challenges include managing latency trade-offs, ensuring reliability through model fallbacks, solving non-trivial problems like turn-taking, and architecting systems to handle complex context while maintaining low cost.

Key takeaways

  1. Architectural Standard: Cascaded Pipeline 3:45

    The current state-of-the-art for reliable voice agents is a cascaded pipeline (Speech-to-Text $\rightarrow$ LLM $\rightarrow$ Text-to-Speech). While Voice-to-Voice models are appealing, they currently lack the necessary reliability and control required for enterprise use cases. [0:03:45]

  2. The Latency vs. Intelligence Trade-off 3:15

    There is an inherent trade-off between the intelligence of the response and the latency. Achieving highly intelligent responses often results in slower processing, which must be managed to feel natural to the end user. [0:03:15]

  3. Complexity of Conversation Flow 3:05

    Solving conversational nuances like turn-taking (knowing when a pause means thinking versus ending the conversation) is not trivial. Furthermore, systems must account for different use cases: outbound calls are easier because guardrails can be strict, while inbound calls require handling unknown user context. [0:03:25]

  4. Optimizing LLM Context and Cost 3:58

    Due to the limitations of LLMs (forgetting information in the middle of a massive prompt), advanced architectures must employ context optimization techniques. This includes using specialized models or implementing 'compaction' methods, which is becoming critical for both performance and unit economics. [0:03:58]

Watch on YouTube Full article

Lada Kesseler: I Trust AI Tests Less Than AI Code thumbnail

· 45:51

Lada Kesseler: I Trust AI Tests Less Than AI Code

Lada Kesseler discusses advanced agentic workflows, arguing that achieving quality with AI agents requires structured 'loop engineering' rather than expecting perfect first attempts. She emphasizes giving agents explicit missions to disagree with and recommends techniques like iterative refinement (the 'centrifuge') and using specialized skills (like TDD) via front matter activation. For build engineers, the core message is shifting from monolithic code generation to modular, verifiable processes that manage complexity through deterministic triggers and layered testing.

Key takeaways

  1. The Centrifuge Principle 11:39

    Quality requires iterative refinement; do not expect AI-generated output to be perfect on the first try. The process involves taking one step, committing it to a file, reading it back, identifying flaws, and repeating the loop until satisfactory (00:13:09).

  2. Agent Ground Rules are for Agents, Not Humans 10:22

    The 'ground rules' or system prompts must give the model a mission to disagree with you (e.g., 'Don't try to please me') rather than just listing best practices. The description field in an agent skill is intended for machine activation, not human readability (00:10:02).

  3. Sketch Prototypes with Markdown 20:43

    For early-stage architecture or complex problem spaces, replace code with a markdown file and an agent. This allows the user to experience the workflow's user experience without committing to production code, serving as a fast, low-fidelity prototype (00:20:43).

  4. Deterministic Verification is Key 27:28

    Use 'verifiers' or deterministic triggers that check for specific standards (e.g., long methods, adherence to style guides) across various files, providing far better results than a single general code review prompt (00:35:29).

Watch on YouTube Full article

AI Model vs Agentic Harness: What Actually Drives AI thumbnail

· 8:30

AI Model vs Agentic Harness: What Actually Drives AI

The video distinguishes between the core AI model (the 'brain') and the surrounding infrastructure, or 'agentic harness' (the 'jar'), which is responsible for advanced system capabilities. While models like ChatGPT provide intelligence, it is the harness—comprising tools, memory management, and agentic loops—that allows an AI to perform complex, multi-step software tasks by interacting with external systems.

Key takeaways

  1. AI Model vs. Agentic Harness

    The core AI model (e.g., ChatGPT, Claude) is the neural network itself but cannot independently interact with the outside world; it requires an agentic harness to function as a powerful system.

  2. Components of the Agentic Harness 0:15

    An overall AI agent consists of the AI model plus the agentic harness, which manages tools, memory, and execution loops. These components are critical for real-world performance.

  3. Capability Gains Source 5:40

    Most recent capability gains in generative AI come from improvements in the harness (better tools, memory handling, smarter loops) rather than solely from improvements to the underlying model.

Watch on YouTube Full article

I don't prompt agents anymore... thumbnail

· 22:22

I don't prompt agents anymore...

The video clarifies that 'graph engineering' primarily refers to building **Control Graphs**, which are structured workflows or SOPs designed to make AI agents reliable and predictable. The speaker details three primary methods for implementing these graphs: using dedicated code frameworks (like `LangGraph` or Dynamic Workflow), leveraging the LLM itself as the orchestrator, or employing agent-to-agent communication patterns. Implementing robust graphs requires defining clear nodes/edges, managing state artifacts, and crucially, integrating deterministic tools like verifiers and scripts to ensure reliability.

Key takeaways

  1. Focus on Control Graphs

    The term 'graph' is often misused; the practical focus should be on **Control Graphs**—workflows that enforce SOPs for reliable agent execution. This is distinct from Knowledge Graphs or Graph of Loops (though the latter is a new, complex area).

  2. Implement Reliability Layers 20:57

    For any automated process, setting up a dedicated 'verifier' skill/agent node is critical to building confidence and ensuring the agent's output meets expected standards.

  3. Choose Your Graph Implementation Method

    Graphs can be enforced via: 1) **Code-as-Graph** (using tools like Dynamic Workflow or `LangGraph`), 2) **Large Model as Graph** (defining SOPs in text/JSON for the LLM to follow), or 3) **Agent Teams** (an orchestrator agent managing a team of specialized agents).

  4. Best Practices for Workflow Design

    To maximize reliability, always define clear inputs and outputs for each node. Use dedicated scripts/code for complex data fetching or deterministic steps rather than relying solely on the LLM.

Watch on YouTube Full article

Lecture 113: Every Microsecond Matters: Achieving Near Speed-of-Light Latency in GPU Collectives thumbnail

· 52:53

Lecture 113: Every Microsecond Matters: Achieving Near Speed-of-Light Latency in GPU Collectives

The lecture details advanced low-latency collective communication algorithms for GPU clusters, crucial for accelerating large language model (LLM) inference. The core challenge addressed is that traditional global memory synchronization barriers are significant bottlenecks in auto-regressive decoding phases. Solutions involve novel techniques—such as Low Latency (LL) protocols, Sentinel synchronization, and Double Buffering—that replace explicit barriers by using data arrival itself as the synchronization signal. Furthermore, a new `LL128 atomic` algorithm is introduced to achieve highly scalable, low-overhead reduction operations.

Key takeaways

  1. Latency Bottleneck in LLM Inference 0:53

    During auto-regressive decoding (the decode phase), message sizes are small, and the collective operation is executed repeatedly on the critical path. Saving microseconds per AllReduce can lead to substantial end-to-end speedups [0:53].

  2. Symmetric Memory for Remote Access 1:40

    Symmetric memory allows a GPU kernel to directly calculate and address the corresponding location of an object on another participating GPU, simplifying remote device memory access within kernels [1:40].

  3. Eliminating Global Barriers 2:30

    The primary bottleneck in traditional AllReduce algorithms (like OneShot or TwoShot) is the expensive global memory barrier. New techniques replace these barriers by using data arrival as an implicit synchronization signal, trading space for latency [2:36].

  4. The LL128 Atomic Algorithm 2:55

    A novel approach utilizes atomic additions over MVLink to perform reductions directly into a shared destination buffer. This significantly reduces required scratch buffer space and improves scalability for larger numbers of ranks compared to previous methods [4:30].

Watch on YouTube Full article

Lecture 113: Every Microsecond Matters: Achieving Near Speed-of-Light Latency in GPU Collectives thumbnail

· 57:30

Lecture 113: Every Microsecond Matters: Achieving Near Speed-of-Light Latency in GPU Collectives

This presentation details advanced techniques for achieving near speed-of-light latency in GPU collective communication operations, crucial for modern distributed workloads like LLM inference and scientific computing. The core challenge addressed is the high overhead of traditional global memory barriers during collectives (e.g., AllReduce). The proposed solutions—including Sentinel synchronization, Low Latency (LL) protocols, and the novel LL128 atomic algorithm—eliminate these expensive barriers by using data arrival itself as a synchronization signal. These advancements are packaged into an experimental device-side API to improve performance significantly in large-scale GPU clusters.

Key takeaways

  1. Low Latency is Critical for Specific Regimes 3:58

    Collective latency matters most when message sizes are small, the operation is repeated many times (e.g., auto-regressive decoding), and communication sits directly on the critical path.

  2. Global Memory Barriers are a Major Bottleneck 10:38

    Traditional AllReduce implementations rely on global memory barriers, which can account for 40-50% of the total latency, even when optimizing the data movement itself.

  3. LL128 Atomic Algorithm Improves Scalability 22:45

    The LL128 atomic algorithm leverages 128-byte cache line atomic additions over NVLink, offering superior scalability and reduced scratch buffer space compared to previous low-latency methods.

  4. API Abstraction Simplifies Implementation 17:55

    A new experimental device-side API (Nickel LL Buffer) wraps these complex synchronization techniques (LL, Sentinel, etc.), allowing kernel writers to easily implement low-latency collectives without manually managing polling and buffer resets.

Watch on YouTube Full article

How to trace your vibe-coded agent with W&B Weave thumbnail

· 7:22

How to trace your vibe-coded agent with W&B Weave

The video demonstrates how to implement comprehensive observability for AI agents using Weights & Biases (W&B) Weave and the W&B MCP server. By leveraging the `weave for agents SDK`, engineers can add full tracing—including conversations, turns, LLM calls, and tool executions—to an existing agent's logic without modifying its core code. This instrumentation allows developers to monitor performance metrics, track resource usage (tokens, cost), and debug complex interactions, such as identifying model hallucinations.

Key takeaways

  1. Weave provides deep observability for AI agents

    The tracing structure follows a clear hierarchy: Agent $\to$ Conversation $\to$ Turn $\to$ LLM Call + Tool Call. This detailed view is crucial for understanding agent behavior and performance.

  2. Non-invasive instrumentation using W&B MCP

    Observability can be added by prompting a coding assistant (like Claude Code) to inject the necessary tracing logic via the `weave for agents SDK`, avoiding changes to existing application code.

  3. Debugging and Evaluation Capabilities

    The Weave UI allows engineers to inspect individual conversations and turns, providing step-by-step visibility into tool usage (e.g., Tavali search) and LLM decisions. This is critical for debugging hallucinations or unexpected agent behavior.

Watch on YouTube Full article

Stripe Paid $7.5 Billion For OpenRouter. You Are Living In The Age Of Startups. thumbnail

· 25:19

Stripe Paid $7.5 Billion For OpenRouter. You Are Living In The Age Of Startups.

Stripe's reported $7.5 billion acquisition of OpenRouter (a company valued at $1.3 billion in May) signals a fundamental shift toward the 'intelligence age.' The speaker argues that this massive investment reflects Stripe's belief that intelligence consumption is becoming a core economic flow, necessitating new infrastructure for agent-to-agent commerce. Key technical shifts include the rapid growth of token volume (doubling every 11 weeks), the rise of agents using APIs and command lines directly, and the need for protocols to manage payments, fraud, and routing across hundreds of AI models.

Key takeaways

  1. Stripe's Strategic Bet on Intelligence

    Stripe paid a reported $7.5 billion for OpenRouter, which provides developers one route to over 400 AI models from 80+ providers. This premium suggests Stripe views intelligence consumption as a critical economic flow requiring ownership of the underlying infrastructure.

  2. The New Moore's Law 6:15

    Token volume is cited as the new metric, with OpenRouter's weekly token volume having grown roughly 24,000x since August 2023 and doubling every 11 weeks. This rapid growth indicates that demand for AI services is outpacing traditional organizational absorption.

  3. The Agent-to-Agent Economy 18:05

    The shift involves agents becoming workers, buyers, and suppliers within a company. Stripe's infrastructure (e.g., Stripe Projects) supports this by handling payments, fraud, and billing for machine interactions, moving beyond the traditional human customer journey.

  4. Singularity as an Economic Event 7:45

    Stripe has set January 1, 2026, as the singularity date. This timing is linked to observed parabolic rises in new firm creation and the explosion of command-line usage by coding agents, suggesting a confluence of business formation and non-human actors entering the system.

Watch on YouTube Full article

Anthropic, OpenAI & Thoughtworks on Context Engineering thumbnail

· 10:08

Anthropic, OpenAI & Thoughtworks on Context Engineering

The core challenge in deploying AI agents is shifting from model intelligence to context engineering. Speakers from Anthropic, OpenAI, Thoughtworks, and Tessl argue that the surrounding context—including organizational knowledge, structured guides, and robust feedback loops—is the primary multiplier for agent capability. Key technical concepts include defining new constraints (human time, attention, context window), building specialized harnesses using computational tools like codemods and static analysis, and establishing a Context Development Lifecycle (CDLC) that runs parallel to the traditional Software Development Lifecycle (SDLC).

Key takeaways

  1. Context Engineering Multiplies Intelligence 0:24

    Model intelligence alone is insufficient for durable, scalable products. Context engineering provides the necessary domain-specific knowledge required for agents to succeed within an organization.

  2. Remaining Software Constraints 5:02

    Most traditional software engineering constraints are obsolete. The three remaining foundational limits when using human-agent teams are: human time (the most scarce resource), human/model attention, and the context window size.

  3. Agent Harness Architecture 8:41

    A coding agent harness requires two components: 'guides' that proactively point the agent forward, and 'sensors' that provide immediate feedback for self-correction (e.g., static analysis, logs).

  4. The Context Development Lifecycle (CDLC)

    Humans must own the CDLC while agents handle the SDLC. This involves generating context, evaluating agent performance via runtime observability, and optimizing skills in a continuous loop.

Watch on YouTube Full article

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini thumbnail

· 28:05

Intelligence EXPLOSION: Harness Engineering with Pi Agent, Deepseek, and Gemini

The video addresses the current 'Intelligence Explosion' in Large Language Models (LLMs), noting rapid model releases and aggressive pricing wars. The core thesis is that modern agentic engineering requires moving beyond selecting a single best-in-class model; instead, engineers must build flexible systems to combine compute from multiple models (e.g., Gemini 3.7 Flash, Deepseek V4 Pro, Claude Fable 5) to achieve superior performance, speed, and cost efficiency. The speaker demonstrates three advanced multi-agent orchestration patterns—Opinion, Debate, and Collaborate—using a custom Fusion Harness V2.

Key takeaways

  1. The Principle of Flexible Systems 2:00

    In an era of rapid technological change, the most flexible system wins. Engineers should focus on combining compute rather than selecting a single model (Combine compute, don't select compute).

  2. Multi-Agent Orchestration Patterns 7:10

    Three advanced patterns are demonstrated for leveraging multiple LLMs: **Opinion** (fire one prompt to N models for diverse perspectives); **Debate** (agents argue a claim across multiple rounds, sharing refutations and positions); and **Collaborate** (models propose plans which an 'architect agent' merges into a structured task list with dependencies).

  3. Cost-Performance Analysis 10:20

    While state-of-the-art models like Claude Fable 5 are powerful, they can be vastly more expensive than 'A tier' workhorse compute (e.g., Gemini 3.7 Flash or Deepseek V4 Pro), offering better effective agent hour per token cost.

Watch on YouTube Full article

How AI Coding Agents Understand Your Codebase & Developer Tools thumbnail

· 6:54

How AI Coding Agents Understand Your Codebase & Developer Tools

While AI coding agents excel at generating fast, syntactically correct code, their utility in production environments hinges on 'understanding' rather than just speed. The core argument emphasizes that good code must not only run but also fit the existing architectural patterns and rules of a codebase. To improve, AI tools must demonstrate deep repository awareness, respect established architectural boundaries (like service layers), and adopt a structured workflow: Read $ ightarrow$ Plan $ ightarrow$ Patch $ ightarrow$ Verify $ ightarrow$ Review.

Key takeaways

  1. Codebase Integrity Over Speed

    AI agents often create 'fast chaos' by making technically correct but architecturally inappropriate changes, such as bypassing established service layers (e.g., for logging or permissions).

  2. The Need for Contextual Awareness 2:05

    Effective AI requires more than just the file being edited; it needs repository awareness to understand API contracts, type definitions, and existing utilities without dumping irrelevant files into the prompt.

  3. Structured Workflow is Essential 5:40

    AI tools should not immediately patch. The ideal workflow involves making reasoning visible (planning), allowing developers to review assumptions before any code changes are made.

Watch on YouTube Full article

What Is a Digital Librarian AI Agent? Connecting SQL & Vector Database thumbnail

· 5:21

What Is a Digital Librarian AI Agent? Connecting SQL & Vector Database

The video introduces the concept of a Digital Librarian AI Agent designed to solve the 'what versus why' data problem common in enterprise systems. This agent is an advanced workflow that connects structured data (SQL databases) with unstructured context (vector databases/PDFs). Instead of simply retrieving siloed data, the agent uses LLMs and multi-step reasoning to synthesize information, transforming a repository into a functional reasoning engine capable of delivering grounded answers.

Key takeaways

  1. The 'What vs. Why' Data Problem

    Structured data (the 'what,' e.g., denial status) resides in SQL tables, while the contextual rules and fine print (the 'why,' e.g., policy details) are buried in unstructured documents like PDFs or manuals, leading to fragmented insights.

  2. The Agentic Workflow 2:00

    A Digital Librarian AI Agent performs a six-step process: (1) Read the question; (2) Determine if the answer requires SQL or vector search; (3) Build necessary queries; (4) Execute queries against both databases; (5) Compile results; and (6) Answer the original question with a single, grounded insight.

  3. Advanced Data Retrieval 4:30

    By moving from simple data queries to agentic workflows, systems transition from merely retrieving data points to delivering reasoned answers, turning siloed repositories into reasoning engines that operate at business speed.

Watch on YouTube Full article

The Agent Behind the Curtain: Building the Oz Cloud Agent Platform — Safia Abdalla, Warp thumbnail

· 20:51

The Agent Behind the Curtain: Building the Oz Cloud Agent Platform — Safia Abdalla, Warp

The presentation details the architecture and philosophy behind Warp's cloud agent platform, emphasizing that a successful developer tool must 'absorb complexity before it reaches the user.' The platform achieves this by providing structured environments (sandboxes) and flexible integration points (multi-harness support). Core functionality revolves around advanced agent orchestration—managing complex workflows across multiple sub-agents via both prompting (`/orchestrate`) and comprehensive API exposure. This approach allows non-developers to build sophisticated tooling on top of the system, significantly automating tasks like issue triage and pull request reviews in open-source repositories.

Key takeaways

  1. Platform Complexity Absorption 0:03

    A core principle is that platforms must hide underlying infrastructure complexity from the user. This includes managing where agents run (sandboxes) and supporting diverse developer preferences without fragmentation.

  2. Multi-Harness Support 0:05

    The platform accommodates various developer workflows and tools (harnesses), ensuring consistency by providing structured guardrails around the chosen tool, regardless of whether it is a custom or native solution.

  3. Agent Orchestration 0:08

    Since real engineering rarely fits into one prompt, agents are designed to orchestrate sub-agents for complex tasks. This can be triggered via a dedicated command (e.g., `/orchestrate`) or programmatically through the exposed API.

  4. API Composability 0:09

    All key primitives—including spinning up agents, managing compute environments, and handling artifacts—are exposed via a robust API. This allows external users (even non-engineers) to build custom tooling (e.g., Slack bots) on top of the platform.

Watch on YouTube Full article