The Video Signal technical video digests

Build A Reasoning Model Scratch 1: Motivation & Code Setup thumbnail

· 43:27

Build A Reasoning Model Scratch 1: Motivation & Code Setup

This video introduces the concept of reasoning models, detailing their evolution from conventional LLMs and how they are utilized within agent harnesses. The core focus is on the educational value of implementing these complex systems 'from scratch' to gain a deep understanding of underlying mechanisms (e.g., reinforcement learning, distillation). Practical steps include setting up the development environment using `uv` for dependency management and PyTorch/JupyterLab for coding.

Key takeaways

  1. LLM Evolution 2:00

    The progression moves from conventional LLMs to reasoning models, which are modified versions of regular LLMs. These reasoning models form the 'engine' used by modern agent harnesses (e.g., OpenAIs Code Agent) [1:16].

  2. Value of From Scratch Learning 8:23

    Implementing models from scratch provides unambiguous, precise code examples that are highly valuable for deep learning understanding, serving as a 'proof' beyond mere conceptual images [8:23].

  3. Setup Workflow 20:40

    The recommended setup involves cloning the GitHub repository and using `uv` (a fast dependency manager) to sync dependencies within an isolated virtual environment before running code in JupyterLab or VS Code [20:40].

Watch on YouTube Full article

Why Does AI Need Access to the Web? thumbnail

· 19:03

Why Does AI Need Access to the Web?

Large Language Models (LLMs) are inherently limited because they operate as pre-trained snapshots, meaning their knowledge freezes after training and cannot account for real-time changes in the world. To build reliable AI agents that function in dynamic environments, the system must incorporate a robust Knowledge Layer fed by a specialized Web Data Infrastructure Layer. This infrastructure is necessary to provide fresh, structured, and trustworthy web data at inference time, thereby eliminating 'Garbage In, Garbage Out' (GIGO) errors.

Key takeaways

  1. LLMs are Static Snapshots 0:25

    Pre-trained LLMs only contain knowledge up to their training cutoff date. When released, they cannot account for new products, laws, or daily news events, leading to potential hallucinations [0:25].

  2. AI Agents Require Real-Time Context 1:30

    Unlike humans who can recognize and ignore incorrect information, AI agents act on all received data. If they receive outdated or fabricated information, the consequences can be costly and happen at scale [1:30].

  3. The Solution: Knowledge Layer & Web Data Infrastructure 2:20

    The most impactful leap in AI functionality is connecting models to a live context via a robust knowledge layer. This layer must receive fresh, reliable data from the web through a specialized web data infrastructure [3:25].

Watch on YouTube Full article

Tell the Robot What You Want — Sandhya Subramani, AWS thumbnail

· 17:23

Tell the Robot What You Want — Sandhya Subramani, AWS

The presentation demonstrates 'Scout,' a rover running on a Raspberry Pi, that has been upgraded from a traditionally programmed robot into an agentic system using AWS's open-source framework, `strands`. This architecture allows the robot to understand and execute complex commands in natural language (e.g., counting people or responding to arbitrary prompts) by having an AI agent orchestrate calls to existing hardware policies/tools. The system utilizes a multi-agent setup (thinker, communication, voice) and operates on a hybrid cloud/edge model for both training (VLA models) and fast runtime execution.

Key takeaways

  1. Agentic Robotics Architecture 2:07

    By implementing an agent layer above existing movement policies, the robot can perform tasks it was never explicitly trained for. The agent decides *what* to do, while the policy determines *how* to execute the action.

  2. Multi-Agent System Design 5:46

    Scout runs three simultaneous agents: a thinker (constantly assessing the environment), a communication agent (via Telegram/web app), and an optional voice agent, allowing for complex, concurrent decision-making.

  3. Hybrid Cloud/Edge Deployment 11:57

    The system is designed to operate on a hybrid model: training (VLA models) occurs in the cloud using `agentcore`, while execution and policy calls happen rapidly at the edge (on the robot's local hardware).

Watch on YouTube Full article

The Signal Layer: What to Build When Anything Can Be Built — Lena Hall, Akamai thumbnail

· 19:44

The Signal Layer: What to Build When Anything Can Be Built — Lena Hall, Akamai

In an era of 'drowning in abundance' where AI makes virtually anything technically buildable, the value has shifted from implementation speed to defining and protecting a unique signal. The talk introduces the concept of the 'signal layer,' which involves two parts: clearly defining your unique signal (the 'build side') and ensuring it survives transmission without distortion (the 'ship side'). Since broad taste is trainable by models, true differentiation requires judgment about unobserved relationships or future events—areas where AI cannot yet operate. The ultimate goal is building trust, which must be actively engineered through careful product design and go-to-market strategy.

Key takeaways

  1. The Value Shift 2:00

    Because automation has driven the cost of average work to zero, the superpower is no longer using AI, but deciding *what* problem deserves an attack. The scarce skill is choosing which problem to focus on.

  2. The Signal Layer 5:50

    Differentiation requires a 'signal layer'—a deliberate function ensuring the customer's understanding of your product matches your original intent. This involves defining what makes you unique and protecting that message through all channels.

  3. Judgment vs. Taste 11:53

    Broad 'taste' is merely preference under feedback, which AI systems can learn. True differentiation comes from judgment about things that have not happened yet (no data exists) or insights into unobserved customer relationships.

  4. Hamming's Principle 13:54

    A problem is only important when there is a reasonable attack on it. Since AI provides an 'attack on everything,' the critical task is identifying which problem warrants that effort.

  5. Signal Distortion Fixes

    Signal can break in three places: Source distortion (founders compressing context), Organization distortion (signal getting averaged through management layers), and Machine distortion (AI remixing the message into formats like tweets or one-pagers).

Watch on YouTube Full article

Tribal Dungeons of Global Shipping: AI Agents at Global Scale — Dmitry Buykin, Maersk thumbnail

· 12:02

Tribal Dungeons of Global Shipping: AI Agents at Global Scale — Dmitry Buykin, Maersk

This report details the engineering challenges of operationalizing complex, global business processes using AI agents. The core challenge is translating 'tribal knowledge'—which exists as unstructured Standard Operating Procedures (SOPs) or screenshots—into executable agent workflows. The speaker emphasizes that the system is not the agent loop itself, but rather the surrounding 'refining loop.' This loop involves building robust mechanisms for validation, error handling, and systematic improvement, which requires capturing a vast SOP corpus (estimated 20:1 ratio to runtime).

Key takeaways

  1. The Long Tail Problem

    While happy paths are often automated, the most expensive part of global operations is the 'long tail'—the exceptions and variations that require expert orchestration across multiple incomplete systems.

  2. Agent vs. Expert Knowledge

    SOPs explain what a person sees and clicks (screenshots), but an agent SOP requires complex setup: preconditions, decisions, identifiers, backend calls, validation, recovery, and evidence of successful execution. Experts own the 'what,' and agents own the 'how.'

  3. The Refining Loop is the System 3:34

    The true system is not the agent loop but the surrounding refining loop. This process requires making corrections executable changes, establishing guardrails to prevent unsafe paths, and ensuring behavior is observable.

  4. Scaling Improvement

    Accuracy was not designed upfront; it was earned through systematic effort. The team logged over 100,000 corrections over nine months, using heat maps to prioritize the most beneficial work for experts and engineers.

  5. The Goal of AI Native Operation

    AI native operation is not just about agents in a workflow; it's an adaptive architecture that learns from successful scenarios, aggregates them into composite tools, and allows repeatable rollouts across hundreds of countries.

Watch on YouTube Full article

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe thumbnail

· 20:43

Agentic Sites: Building Hyper Personalized Websites — Carlos Sanchez, Adobe

The presentation details 'Agentic Sites,' a system for building hyper-personalized websites that adapts content in real time based on user intent and browsing behavior. Instead of generating entire pages, the architecture focuses on customizing specific content blocks (e.g., hero sections, product lists) while grounding all generated content within the site's existing corpus to maintain strict brand guidelines. Key technical advancements include continuous model evaluation across multiple providers for both accuracy and speed, achieving impressive generation latencies as low as 1.1 seconds.

Key takeaways

  1. Hyper-Personalization (Audience of One)

    The goal is to personalize pages in real time based on the user's intent or actions, moving beyond one-size-fits-all web experiences. This drives higher engagement and conversions.

  2. Block-Level Personalization 3:40

    Personalization occurs at the block level (e.g., hero card, product list) rather than generating entire pages, which is crucial for adhering to strict brand guidelines and preventing hallucinations.

  3. Speed is Critical for Conversion 10:58

    The system emphasizes speed, noting that a page generation time of 1.1 seconds was significantly faster than the runner-up's 4.6 seconds, demonstrating that low latency is critical to user experience and conversion rates.

Watch on YouTube Full article

Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan thumbnail

· 19:28

Agents Are Where Microservices Were in 2015 — Roberto Milev & Uday Kanagala, Navan

The talk outlines that AI agents represent a paradigm shift comparable to microservices in 2015, requiring entirely new architectural patterns for reliable production deployment. Key areas of focus include managing agent statefulness (moving beyond stateless APIs), implementing advanced observability via hooks and traces, adopting skills as the primary unit of context, and establishing robust governance through guardrails at the policy layer. The industry is moving toward scoring non-deterministic trajectories rather than asserting fixed outputs.

Key takeaways

  1. Agents are Stateful by Nature 3:54

    Unlike traditional stateless API services, agents require persistent sessions and state management, necessitating specialized agentic runtimes (e.g., AWS Agent Core Runtime) [2:34].

  2. Skills as Context Unit 6:04

    To manage context effectively, the focus should be on treating 'skills'—which include instructions and tool execution logic—as pluggable units of work that allow for progressive disclosure of context [6:04].

  3. Observability via Hooks and Traces 7:16

    Because agents emit excessive thinking output, traditional logging fails. Operational reliability requires intercepting every step (pre-tool/post-tool, pre-decision/post-decision) to capture auto-traces, goals, reasoning, belief status, and confidence scores [7:16].

  4. Testing Non-Deterministic Systems 9:32

    Since agents are non-deterministic, testing must shift from asserting fixed outputs to scoring trajectories—evaluating the efficiency and completeness of the path taken toward a goal [9:32].

  5. Guardrails for Authorization 13:44

    The blurring line between an agent acting on behalf of a user versus using its own service account requires fine-grained authorization policies (guardrails) applied before and after every tool call to prevent sensitive data leakage [13:04].

Watch on YouTube Full article

AI Agents Are Just Distributed Systems Now — Salman Munaf, TikTok thumbnail

· 19:48

AI Agents Are Just Distributed Systems Now — Salman Munaf, TikTok

The core argument is that AI agents, once they interact with external services (tools/APIs), cease being purely model problems and become complex distributed systems challenges. Building reliable agents requires incorporating robust distributed systems thinking—focusing on failure modes, state management, transactionality, and security controls—rather than just improving the LLM itself.

Key takeaways

  1. AI Agents as Probabilistic Coordinators 5:46

    Unlike traditional deterministic workflows that follow a predefined decision tree, AI agents act as probabilistic coordinators. This variability necessitates strong external controls (e.g., circuit breakers, spending ceilings) to ensure determinism and prevent severe consequences.

  2. Handling Failure: Timeout vs. Failure 11:59

    A timeout does not mean failure; it means unknown. To prevent unsafe side effects (like double refunds), agents must utilize request IDs and idempotency keys, allowing for status lookups to confirm if an action already succeeded.

  3. State Management and Context 17:37

    Context that influences an action is state. This state can become stale or conflict with the authoritative source of truth, requiring explicit invalidation and provenance tracking, much like managing a cache.

  4. Security and Control Boundaries

    Agents must operate with scoped credentials (separate read/write permissions) and limited tool access. Furthermore, human approval should be bound to specific actions, actors, and expiry times, not blanket privileges.

Watch on YouTube Full article

From Tokenmaxxing to Trusted Throughput — Mingsheng Hong, Ironclad thumbnail

· 23:04

From Tokenmaxxing to Trusted Throughput — Mingsheng Hong, Ironclad

The talk argues that optimizing AI token usage should not focus solely on cost reduction (austerity). Instead, the goal is to maximize 'Trusted Throughput'—the value derived from code validated by internal engineering and external customers. The speaker emphasizes that as AI makes code generation abundant, the bottleneck shifts downstream to Code Review and Continuous Integration (CI/CD). Key strategies include defining advanced metrics (e.g., weighted merged PRs) and improving developer experience by eliminating flaky tests and measuring wait times.

Key takeaways

  1. AI Usage Dashboards as Smoke Detectors 1:34

    Usage dashboards should track token usage across teams/individuals but must not be positioned as leaderboards or incentives for maximization. Instead, they serve as 'smoke detectors' to identify pockets of low adoption or sudden usage anomalies (1:34).

  2. Focus on Trusted Throughput, Not Cost Reduction 13:11

    The metric for ROI should be 'Trusted Throughput'—high-quality output validated by internal engineering and external customers. Attempting to cut cost before measuring value is premature (8:33).

  3. Metrics Evolution Beyond Lines of Code (LOC) 22:25

    The process for measuring value has evolved from LOC, to open PRs, to merged PRs, and finally to weighted merged PRs that incorporate a complexity score. This moves the focus from volume to quality (11:20).

Watch on YouTube Full article

When AI Stops Being a Project: Turning Technology into Real Value for Patients and Providers thumbnail

· 36:50

When AI Stops Being a Project: Turning Technology into Real Value for Patients and Providers

The conversation explores the shift of AI from a mere 'project' to an integral business function in healthcare. Key focus areas include moving beyond simple Q&A chatbots to complex, long-running agentic workflows that can handle tasks previously requiring many hours of human effort. Speakers emphasize that while the technology is rapidly advancing (e.g., GLM 5.2 and advanced LLMs), successful enterprise adoption requires significant architectural changes: establishing robust governance, managing token costs, mitigating vendor lock-in, and fundamentally reimagining existing clinical workflows rather than simply automating point solutions.

Key takeaways

  1. Shift to Agentic Workflows 14:25

    AI is moving past simple Q&A (quick, short, transactional) toward complex, long-running agentic tasks. OpenAI internal data suggests agents are now performing work across finance, recruiting, and legal that can take up to 8 hours of human effort [0:14:25].

  2. Governance and Architecture are Critical 23:15

    For large enterprises (like United Health Group), long-form agentic work requires establishing strong governance, guardrails, and security protocols. Simply calling an API a 'super agent' is insufficient; true agency requires reasoning and decision-making capabilities [0:23:15].

  3. Addressing Vendor Lock-in and Cost 4:46

    Enterprises must manage the risks of vendor lock-in when restructuring workflows around a single model or API. Concerns include escalating token costs and geopolitical instability, making architectural flexibility paramount [0:47:28].

  4. Reimagining vs. Automating Silos 3:31

    The most impactful approach is not to automate existing tasks (silos) but to fundamentally reimagine the entire end-to-end workflow—from patient intake to payment processing—given the new technological capabilities [0:35:12].

  5. AI as a Business Mandate 5:46

    Successful adoption requires AI to be elevated from an IT or innovation problem to a CEO-level, cross-functional business mandate. Leadership must obsess over defining the core metrics (the 'what is the metric?') and driving change at scale [0:57:12].

Watch on YouTube Full article

NVIDIA Dynamo in 5 Minutes: What Is It and Why Now? thumbnail

· 6:03

NVIDIA Dynamo in 5 Minutes: What Is It and Why Now?

NVIDIA Dynamo is a distributed serving layer designed to complement existing LLM inference engines (like SGLang, TensorRT-LLM, or vLLM). It addresses the complex challenges of scaling large language model inference across multi-GPU and multi-node clusters. Instead of being an inference engine itself, Dynamo coordinates workers, manages request routing, ensures fault tolerance, optimizes resource utilization through KV cache reuse, and provides a modular architecture for building complex production serving stacks.

Key takeaways

  1. Dynamo's Role in Scaling

    Dynamo acts as a distributed serving layer *around* inference engines. It coordinates the system to achieve multi-GPU and multi-node performance that single engines cannot provide alone. (0:32)

  2. Disaggregated Serving Efficiency 3:40

    It helps coordinate prefill (input prompt processing) and decode (token generation) phases across worker pools, which can have different resource needs, improving efficiency. (2:20)

  3. System Reliability and Scaling 5:05

    Dynamo provides crucial capabilities for production environments, including advanced request routing based on capacity/worker state, fault tolerance against node failures, and composability to connect various system components. (3:05)

Watch on YouTube Full article

AI-Native Organisations Run on Skills: How to Structure and Scale Them — Imad Touil, QuantumBlack thumbnail

· 20:31

AI-Native Organisations Run on Skills: How to Structure and Scale Them — Imad Touil, QuantumBlack

The talk argues that in AI-native organizations, organizational know-how resides primarily within 'skills.' While skills offer deterministic outcomes for complex workflows, ungoverned skills quickly accumulate as a form of technical debt due to duplication and quality decay. To scale effectively, organizations must adopt governance principles—borrowing from the microservices era—by implementing a centralized skills platform that provides metadata, search, versioning, access control, and clear ownership.

Key takeaways

  1. Skills are the core of organizational know-how 11:43

    The agentic software stack relies heavily on 'skills' (the deterministic component) within its outer workflow loop. If skills are unstructured, the resulting workflow is not truly deterministic.

  2. Governance prevents technical debt 20:30

    Without governance, teams repeatedly build similar skills (duplication), quality degrades because skills aren't retested against new models, and ownership is unclear. This creates a new class of technical debt.

  3. A centralized platform is mandatory for scale

    Scaling requires a central skills catalog with metadata, dependency mapping, versioning (to pull the current release), access control, and named human owners across architecture, infrastructure, and security.

Watch on YouTube Full article

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS thumbnail

· 10:07

Your Code Has Bugs. Lean4 Has Proofs: Formal Verification for Engineers — Varun Pant, AWS

As AI coding agents generate massive amounts of code, traditional checks (probabilistic model grading, input-limited tests, human review) are insufficient to guarantee correctness for all inputs. Formal verification provides mathematical proof that code satisfies a precise specification. The methodology involves humans owning the specification and machines handling both the implementation and the formal proof. Tools like Lean allow the same language for defining code and proofs, enabling robust systems where production code (e.g., Rust) is reconciled against specifications written in Lean, often through differential random testing.

Key takeaways

  1. Limitations of Current Code Checks

    None of the usual checks—AI model grading (probabilistic), unit tests (limited inputs), or human review (non-scalable)—can guarantee that code is correct for every possible input. Formal verification provides mathematical proof of correctness for all inputs.

  2. The Specification Hierarchy 2:00

    In formal verification, humans own the specification (what 'correct' means). This specification must be validated first because it is the upstream artifact; everything else (code and proof) is downstream from it. The AI coding agent then implements code based on this spec.

  3. Lean as a Unified Language 4:00

    Lean functions as both a programming language and a proof assistant, eliminating translation layers. It allows the same language to define definitions (code) and proofs (theorems).

Watch on YouTube Full article

How do you diffuse AI into the real world? — Varun Shenoy, Long Lake thumbnail

· 17:46

How do you diffuse AI into the real world? — Varun Shenoy, Long Lake

The deployment of advanced AI agents into real-world service industries is not merely a technological challenge but an operational one. Drawing parallels to the adoption of electricity and Ford's assembly line, the speaker argues that technology diffusion takes generations. Long Lake addresses this by acquiring and operating services businesses (e.g., property management) rather than selling software. Their approach focuses on building AI agents that move beyond simple 'co-pilots' to become autonomous 'co-workers,' leveraging proprietary ground truth data collected from messy, real-world tasks—a process requiring deep, physical co-design with the industry.

Key takeaways

  1. AI Diffusion Takes Generations 1:30

    The adoption of general-purpose technologies (GPTs) is slow. Just as electricity took decades to fully integrate into industries like Ford's, AI requires massive operational shifts—ripping out old processes and retraining staff—to achieve full diffusion. [1:30]

  2. The Value of Owning the Outcome 2:36

    Long Lake does not sell AI software; they acquire and operate services businesses (e.g., HOA, architecture). By being the operator/owner, they bear the risk when the AI fails, ensuring deep integration and accountability that external vendors cannot match. [2:36]

  3. The Progression from Co-pilot to Co-worker 6:18

    AI agents must progress through stages of autonomy: Co-pilot (simple RAG chatbot) $ ightarrow$ Synchronous Agent (real-time, two-way interaction) $ ightarrow$ Asynchronous Agent (background work, external triggers) $ ightarrow$ Long-running Agent $ ightarrow$ AI Co-worker (proactive partner). Achieving the co-worker requires earning the right to do more through iterative field deployment. [6:02]

Watch on YouTube Full article

How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma thumbnail

· 17:43

How to Get Your Org to Adopt Coding Agents (Without Shipping Garbage) — Eyal Blum, Figma

The talk outlines Figma's strategy for safely adopting AI agents in a large-scale codebase. The core message is that successful adoption requires shifting focus from simply prompting agents to building robust verification mechanisms and structured planning processes. Key recommendations include making communication attention-aware (marking human vs. AI text) and structuring complex tasks using detailed plans, which are then broken down into small, independently verifiable components.

Key takeaways

  1. The Role of Skeptics in Adoption 5:25

    Best engineers, who hold institutional knowledge (the 'mental duct tape'), tend to be the slowest adopters because they are best positioned to spot failure modes and missing validation. Instead of forcing adoption, organizations should involve these skeptics by making them responsible for defining the roadmap to make AI safe.

  2. The Three Acts of AI Adoption 0:45

    AI adoption follows a three-act process: (1) Simple, successful use cases; (2) Applying practices to bigger problems where AI fails badly and trust breaks down; and (3) Building the real skill by implementing proper guardrails, context, and prompting for scale.

  3. Planning Over Prompting 10:30

    For complex features, spending significant time writing a detailed plan is more effective than simply prompting the agent. A good plan must start with a 'Why' (executive summary) and be broken down into small parts that can each be verified independently.

  4. Attention-Aware Communication

    Since human attention is scarce, it is crucial to build a culture of self-communication by explicitly marking what content was generated by AI versus what was written by a human (e.g., starting PR descriptions with a manual summary).

Watch on YouTube Full article

From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS thumbnail

· 20:57

From AI-Assisted to AI-Native: Building a Frontier Development Team — Clare Liguori, AWS

Frontier development represents a step-function improvement in productivity using AI agents, moving beyond simple coding assistance. The core finding is that success is not dependent on the tools themselves, but rather on intentionally changing engineering workflows and building new habits. Key practices include investing heavily in agent context, slowing down to refactor codebases (e.g., migrating from untyped languages like Python/JavaScript to TypeScript or Rust), implementing parallel agent execution, making intent explicit via documentation, and shifting testing left using local deterministic mocks.

Key takeaways

  1. Frontier Development Definition

    Productivity gains are characterized by engineers writing only 1-2% of the code; agents running for hours without interruption; and multiple agents operating in parallel. This represents a median productivity improvement of 4.5x to over 10x compared to previous AI phases (0:00, 7:04).

  2. The Importance of Process Over Tools 11:44

    A pilot study involving 50 teams on existing codebases found that the difference between <3x and >4.5x productivity gains was determined by how the team worked, not the AI tools used (9:21).

  3. New Bottleneck Identification 18:58

    As coding speed increases dramatically, the bottleneck shifts from writing code to decision-making speed and organizational review processes. Fast decisions, especially reversible ones, are critical for scaling (11:38).

Watch on YouTube Full article

Inside Clay's Eval Stack: 300M Agent Runs, One LangSmith Pipeline thumbnail

· 13:01

Inside Clay's Eval Stack: 300M Agent Runs, One LangSmith Pipeline

Clay detailed its agentic stack, featuring Claygent (go-to-market research) and Sculptor (go-to-market engineering workflow orchestration). The discussion emphasized that scaling agents to millions of runs requires a robust evaluation philosophy. Key architectural shifts include adopting a data lake for unified first/third-party data access, implementing comprehensive multi-stage evaluations (from local dev to CI), and leveraging large context models (like Fable) to enable complex, self-iterating agent loops.

Key takeaways

  1. Agentic Systems are Becoming Interfaces

    Clay is evolving into an 'agent interface,' making all parts of the product available via CLI and public API. This creates a flywheel where internal and external agents share the same tools, allowing failures in tool invocation to provide user signal for continuous improvement.

  2. Evals are Non-Negotiable for Scale 3:23

    With billions of runs, comprehensive evaluation suites are critical. Clay's philosophy mandates different levels of testing: low-lift local dev checks, and staging/CI environments that mirror production harnesses.

  3. Data Lake Foundation for Agents

    To handle disparate data sources (LangChain traces, Snowflake, Postgres, ClickHouse), Clay is moving to a data lake architecture. This allows agents to run wild on unified first-party and third-party data while enabling safe shadow builds.

Watch on YouTube Full article

How to avoid disaster when vibe-coding a billing engine — Andrew Garvin, Stripe thumbnail

· 17:49

How to avoid disaster when vibe-coding a billing engine — Andrew Garvin, Stripe

Andrew Garvin discusses the complexities of building a billing engine, particularly when integrating advanced AI agents. He emphasizes that because billing involves deep business logic and real money, full autonomy is risky. The solution presented is using agentic tools (like Stripe Projects) to accelerate development into controlled test environments (sandboxes), rather than deploying directly to production. Key architectural components include portable 'skills files' for context and verbose error messaging for self-correction.

Key takeaways

  1. Agent Guardrails are Essential for Billing 11:53

    Billing carries deep business logic; therefore, the recommendation is to use coding agents only to accelerate development into a test environment (sandbox), not to ship directly to production. This minimizes risk when dealing with financial data.

  2. Skills Files Provide Contextual Guardrails 10:02

    To manage complexity, Metronome uses an extensible set of portable 'skills files' that provide necessary context and API knowledge to the agent, removing friction during setup and evolution.

  3. Shift from Seats to Credits (Usage-Based Pricing) 17:18

    The rise of agents operating entire systems necessitates a shift away from seat-based pricing models toward usage-based credit systems. This is crucial because the value may accrue to a single agent/user, not a fixed number of logins.

Watch on YouTube Full article

Productionizing LLM Gateways: Architecture, Tradeoffs and Hard Lessons — Kanish Manuja, Twilio thumbnail

· 16:24

Productionizing LLM Gateways: Architecture, Tradeoffs and Hard Lessons — Kanish Manuja, Twilio

This talk details the architecture and trade-offs involved in building an LLM Gateway—a middleware layer managing routing, authentication, fallbacks, and governance between applications and model providers. The core challenge is that availability, latency, guardrails, and cost cannot all be maximized simultaneously during degradation. Key architectural advice includes preferring per-request fallbacks over blind retries or circuit breakers, tracking P99 latency per model/route (not gateway-wide), and treating guardrails as unreliable services requiring fail-open/fail-close decisions.

Key takeaways

  1. LLM Gateway Core Trade-offs 2:11

    An LLM gateway must manage a permanent fight between availability, latency, guardrails, and cost. Degradation forces the system to sacrifice one of these four elements (1:21).

  2. Fallback Strategy 2:33

    Instead of blind retries or circuit breakers, implement per-request fallbacks (trying Model A, then B if A fails) or parallel requests for low-latency needs. This prevents multiplying cost and tail latencies (2:33).

  3. Latency Measurement Best Practices 7:08

    Do not measure gateway-wide latency; instead, track P99 per model and per route. Setting timeouts on a per-model/per-route basis is critical to preventing silent outages (7:08).

  4. Guardrails as Services 10:40

    Treat guardrails (e.g., toxicity filters, PII checks) like any other service that can fail. Teams must decide in advance whether the system should 'fail open' (serve request despite failure) or 'fail close' (block request) (10:40).

  5. Centralization vs. Governance 13:02

    While many teams seek a central gateway, the underlying need is often centralized governance (e.g., cost tracking, rate limiting), which can be achieved by decentralizing traffic while centralizing policy enforcement (13:02).

Watch on YouTube Full article

How I Fight AI Brain Rot. Friction Maxxing With Codex, Grok And Claude. thumbnail

· 27:19

How I Fight AI Brain Rot. Friction Maxxing With Codex, Grok And Claude.

Instead of viewing AI as a tool for friction removal, the speaker advocates for 'friction maxxing'—deliberately adding resistance to maintain critical judgment. This involves constantly comparing outputs across multiple models (Codex, Grok, Claude) and incorporating human feedback to challenge assumptions. The goal is not just efficiency, but developing a robust mental model of agent capabilities, failure boundaries, and the limits of current AI interfaces.

Key takeaways

  1. The Value of Disagreement

    True insight comes from disagreement. By forcing multiple models (e.g., Codex, Grok, Claude) to argue or solve a problem, the resulting solution is more robust than any single model's initial output. The speaker emphasizes that 'disagreement is like a rep for my brain.'

  2. Testing Agent Boundaries (The Wrong Spreadsheet) 23:40

    When testing new agents, focus not on the stated claims but on their ability to transparently disclose what they can and cannot access. A dangerous failure mode is when an agent presents a completed draft while having used outdated or inaccessible data (e.g., pulling an old spreadsheet copy because it couldn't reach the downloads folder).

  3. Resisting Gradient Descent 17:33

    Most AI interfaces encourage 'relentless gradient descent,' pushing users toward simple corrections (e.g., fixing a bug or improving a paragraph). The challenge for humans is to ask if the iteration changes our thinking and pushes us creatively, rather than just moving the output closer to the center of the model's known distribution.

  4. The Human Feedback Loop

    Human community feedback is crucial for developing a sophisticated world model. By cycling human critique (e.g., 'this design is confusing') back into the AI, users can ask models to explain which assumptions led to the flawed output, thereby deepening understanding.

Watch on YouTube Full article