LangChain — The Video Signal

Aug 10, 2026 · 10:39

Create an agent that can browse the web with Managed Deep Agents and Browserbase's Stagehand

This video demonstrates building a production-ready web browsing agent by integrating Managed Deep Agents (LangSmith) with Stagehand v4 and BrowserStack. The resulting agent can interact with live websites—performing actions like scrolling, clicking, and navigating—using specialized tools exposed by Stagehand to connect the AI model to scalable browser infrastructure.

Key takeaways

Agent Architecture Overview
The solution uses Managed Deep Agents as the core agent harness (LangSmith), which is augmented with tools from Stagehand v4. Stagehand, in turn, connects to web browsing infrastructure provided by BrowserStack for production-grade scalability.
Stagehand V4 Tools 3:57
The agent is given three core tools from Stagehand: `screenshot` (visually inspects the rendered page), `snapshot` (inspects the active page and hydrates element IDs for simple interactions), and `run` (accepts snapshot actions or JavaScript via the Playwright-shaped page API, ideal for multi-step workflows).
Development Workflow (Local vs. Production) 6:00
The development process involves running `mda dev` locally to test the agent in a managed deep agent studio environment. For production, the deployment is finalized using `mda deploy`, which creates a serverless deployment within LangSmith's Context Hub.

Watch on YouTube Full article

Aug 5, 2026 · 53:34

How I helped developers talk about feelings and needs - Gitte Klitgaard - NDC Copenhagen 2026

While the video metadata focuses on advanced AI security topics like Fine-Grained Authorization (FGA) for Retrieval-Augmented Generation (RAG), the talk itself addresses organizational communication and psychological safety. The speaker emphasizes that effective collaboration requires explicit tools, setting clear 'frames' (rules of engagement), and creating a safe space where developers feel comfortable discussing needs and emotions without fear of judgment or professional facade.

Key takeaways

The Importance of Psychological Safety 17:05
Psychological safety is defined as feeling secure enough to be oneself, disagree, and bring all of your thoughts to work without fear of ridicule or punishment. This requires active effort, especially in remote settings.
Communication Requires Tools 21:45
Effective communication is not innate; it requires specific skills and tools (like structured workshops or 'rules of engagement'). Simply working together does not guarantee successful collaboration.
The Power of Framing 34:10
Setting a clear frame—or set of rules—for a project or meeting is crucial for creativity and open discussion. Constraints, like those used in Lego design, can actually stimulate better ideas.
Addressing AI Misunderstandings 38:20
When discussing complex topics like Generative AI, teams must ensure they are all talking about the same thing (e.g., distinguishing between different types of 'spam' or AI implementation) to avoid major misunderstandings.

Watch on YouTube Full article

Jul 31, 2026 · 15:40

Building Deep Agents and Deploying in Production

Deep Agents are defined as a sophisticated 'harness' built around foundational LLMs, providing the necessary infrastructure—beyond just the model itself—to make agents reliable and useful in production. The system integrates core primitives like memory, tools, file systems (acting as scratchpads), and middleware hooks. For deployment, critical considerations include implementing durable execution via checkpointing, managing short and long-term memory stores, establishing robust Role-Based Access Control (RBAC) for tool access, and designing for human oversight (human in the loop).

Key takeaways

Deep Agents are a 'Harness' 0:27
An agent is conceptualized as an LLM plus a harness. The harness encompasses all infrastructure—including system prompts, memory management, tools, file systems, and middleware—that makes the model reliable for a given task. (0:27)
Deep Agents Architecture 6:58
Deep Agents represent the highest level of abstraction in the LangChain stack, built on top of LangGraph, which provides the core composable nodes and edges necessary for complex agent workflows. (4:18)
Production Reliability Requirements
For production deployment, agents must handle long-running tasks using durable execution (checkpointing) to recover from failures at any step, manage short/long-term memory across sessions, and incorporate human approval loops. (9:48)

Watch on YouTube Full article

Jul 24, 2026 · 41:14

Inside the Agent Engine: A LangChain and Traversal Fireside Chat

The discussion details the challenges and architectural requirements for building AI Site Reliability Engineering (SRE) agents capable of handling petabyte-scale production incidents. Speakers emphasize that SRE troubleshooting is uniquely difficult due to the lack of labeled data, high stakes, and massive telemetry volumes. Successful agent design requires moving beyond simple RAG/vector search by implementing sophisticated 'agent harnesses' that manage context via file systems, build a comprehensive 'production world model,' and strategically balance offline vs. online computation.

Key takeaways

SRE Agents Face Unique Data Challenges 3:23
Troubleshooting is difficult because there is no good labeled data for LLMs to train on, human troubleshooting processes are complex, and the scale of telemetry (e.g., petabytes per day) makes traditional context window methods infeasible.
Agent Architecture Requires a Core/Sub-Agent Harness 11:30
Instead of monolithic agents, the recommended approach is building one core agent that orchestrates multiple specialized sub-agents. This requires a robust harness to manage context and file systems effectively.
The Production World Model is Key to System Knowledge 7:50
Learning system knowledge involves synthesizing large streams of non-telemetry data (e.g., code, Slack) with raw observability logs to build a 'production world model,' which acts as the system's deep wiki.
Evaluation Must Focus on Hardest Tasks 30:50
When evaluating agents, focus on the hardest tasks (like incident RCA) because success in these complex areas tends to generalize better than focusing on easier, less representative tasks.

Watch on YouTube Full article

Jul 22, 2026 · 45:17

The Agent Development Lifecycle 101 by Harrison Chase

The Agent Development Lifecycle outlines a systematic approach for moving AI agents from isolated demos to reliable production systems. The process is broken down into five stages: Build, Test, Deploy, Monitor, and Govern. Key focus areas include ensuring agent reliability at scale by implementing durable execution, managing complex state via virtual file systems, and using advanced observability tools like tracing and online evaluation (evals) to detect failures and drive continuous improvement.

Key takeaways

Systematic Iteration is Key 3:50
Successful teams treat agents not as one-off projects but as systems requiring systematic iteration across the entire lifecycle: build, test, deploy, monitor, and improve. The primary challenge in shipping agents reliably at scale is ensuring consistent behavior.
Agent Development Components 5:50
The core components are Build (frameworks/harnesses), Test (data sets, metrics, benchmarks like Terminal Bench 2), Deploy (durable execution, sandboxes), Monitor (tracing, online evals), and Govern (cost control, tool access management).
The Role of Tracing and Observability 17:06
Tracing is fundamental for debugging agents, allowing developers to see the inputs and outputs at every step (including tool calls) to understand why an LLM or agent failed. Online evals extend this by scoring production traces without needing ground truth.
Self-Improving Agents 31:30
Advanced platforms, like LangSmith Engine, are beginning to automate the improvement loop. They run in the background over existing traces, clustering issues and suggesting fixes (code or prompt changes), thereby drastically lowering the burden of operating agents at scale.

Watch on YouTube Full article

Jul 22, 2026 · 8:02

/goal: Building big features with dcode

The video introduces `dcode`, an open-source, model-agnostic coding agent, and its new `/goal` command. This feature enables long-running, persistent tasks by wrapping the standard agent loop in a 'goal loop.' Instead of relying on single-shot requests for large features (like meaty PRs), `/goal` establishes visible acceptance criteria that guide the agent's work over hours. The demonstration shows how to use this mechanism to add native browser control to `dcode`, allowing the user to steer, amend requirements, and inspect progress using tools like LangSmith tracing.

Key takeaways

The /goal Command 2:50
The `/goal` command provides a long-running, persistent objective for agents tackling large tasks. It shifts alignment work upfront, making it visible and allowing mid-run tailoring of requirements (3:46).
Goal Loop Mechanism 0:35
The goal loop wraps the agent's inner action loop. The outer loop continuously checks if actions satisfy the durable acceptance criteria; if not, the goal remains active until evidence satisfies all requirements (0:17).
Steering and Amending Goals 4:40
Users can inspect the current state with `/goal show` or update/correct requirements mid-run using `/goal amend`, which interprets the message within the context of the active goal (3:46).

Watch on YouTube Full article

Jul 22, 2026 · 18:05

60% Faster Time-to-Interview: Transforming Hiring with AI Agents with LangChain

LinkedIn details the architecture of a hiring agent built with LangChain and LangGraph that successfully cut time-to-interview by 60% for small businesses. The system evolved from static workflows to an advanced agentic control model utilizing a central planner within a plan-execute-replan loop. Key architectural components include specialized memory types (conversational and experiential), middleware hooks for PII detection, and rigorous 'harness engineering' techniques—such as state flag chaining and one-shot tool guards—to ensure the probabilistic nature of LLMs results in a dependable product.

Key takeaways

Hiring is an Agent Problem
The hiring process is inherently iterative (plan, act, observe, adapt), requiring continuous adaptation rather than being a one-shot task. This necessitates an agentic approach.
Architectural Evolution to LangGraph 0:03
The system progressed from hard-coded static workflows (if/then) to sequential LangChain chains, culminating in LangGraph for its true agentic control model featuring a central planner and plan-execute-replan loop.
Choosing LangGraph 0:05
LinkedIn selected LangGraph over 89 evaluated frameworks because it complements existing infrastructure, builds upon core LangChain primitives (runnables, tools), and allowed for zero rewrite adoption.
Achieving Determinism via Harness Engineering 0:10
To make the agent dependable, LinkedIn implemented advanced 'harness engineering' techniques, including context management (checkpoint trimming), output format determinism (template confirmation/fallbacks), and node-change determinism (state flag chaining and one-shot tool guards).

Watch on YouTube Full article