Topic

Deep Agents

All digests tagged Deep Agents

Building Deep Agents and Deploying in Production thumbnail

· 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

  1. 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)

  2. 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)

  3. 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

Inside the Agent Engine: A LangChain and Traversal Fireside Chat thumbnail

· 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

  1. 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.

  2. 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.

  3. 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.

  4. 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

The Agent Development Lifecycle 101 by Harrison Chase thumbnail

· 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

  1. 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.

  2. 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).

  3. 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.

  4. 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