#543: Deep Agents: LangChain's SDK for Agents That Plan and Delegate

Summary of #543: Deep Agents: LangChain's SDK for Agents That Plan and Delegate

by Michael Kennedy

1h 3m•April 1, 2026
Listen to Episode

Overview of #543: Deep Agents — LangChain's SDK for agents that plan and delegate

Michael Kennedy interviews Sydney (from LangChain) about DeepAgents — LangChain’s open‑source agent harness and SDK for building “deep” agents: agentic systems that plan, iterate, call tools, access files, spawn sub‑agents, summarize context, and generally behave more like human problem solvers than single LLM prompt/response interactions. The episode explains the core harness components, the LangChain/LangGraph stack, common patterns (planning, file system, subagents, middleware), safety patterns, example applications, and where the project is heading.

Main takeaways

  • “Shallow” agents are simple model+tool loops for short tasks. “Deep” agents have richer context, longer horizons, planning, parallel/subtasks, memory, and robust tool integration.
  • An agent harness = the extra infrastructure around the model/tool loop (planning, file access, subagents, system prompts, summarization, middleware, etc.) that makes long‑running, complex agent behavior practical and reliable.
  • DeepAgents (LangChain) is an open‑source harness and SDK to build such agents in Python. It’s model‑agnostic, supports MCP tools, middleware hooks, and integrates with LangChain and LangGraph under the hood.
  • Key developer ergonomics: define tools as normal Python functions (docstrings + types used to generate schemas), middleware lifecycle hooks, prompt caching, automatic summarization/compaction, and support for multiple UIs (CLI, notebook, LangGraph dev UI).
  • Safety model: enforce constraints at tool/sandbox boundaries; use human‑in‑the‑loop approvals, whitelisting, and sandboxes rather than expecting LLMs to self‑police.

DeepAgents (LangChain) — Features & components

  • Planning tool
    • Provides an explicit to‑do / plan that the agent checks off. Greatly improves agent trajectory for complex tasks.
  • File system access
    • Remote/local file systems (S3, DB‑backed etc.) let agents manage and store large context incrementally instead of cramming everything into one prompt.
  • Sub‑agents
    • Fan‑out work for parallelism and context isolation. Useful for parallel research, editing many files, or exploring multiple hypotheses concurrently.
  • System prompts + memory
    • Long, carefully crafted system prompts (examples showed ~16,000 words for Claude Code) power agent behavior; DeepAgents supports prompt caching to reduce cost.
  • Tools as Python functions
    • Tools are regular Python functions (with docstrings and type hints). The SDK parses signatures and docs (often augmented by Pydantic) into schemas for the model to call accurately.
  • MCP (Model Context Protocol) support
    • Can consume standardized tools from MCP servers so agents can call tools exposed by other services/teams.
  • Middleware lifecycle hooks
    • Hook into pre/post model and tool events: summarization, human approval, retries/fallbacks, PII detection, permission checks, etc.
  • Summarization / context compaction
    • Built‑in compaction ensures long conversations don’t overflow model context windows.
  • Model‑agnostic & model mixing
    • Use any provider/model; subagents can use cheaper/faster models for specific sub‑tasks while main agent uses a higher‑quality model.
  • CLIs and UIs
    • DeepAgents powers a CLI similar to Claude Code, Jupyter notebook demos, LangGraph dev UI for trace inspection, and LangChain’s Agent Builder (no‑code) product.

Programming model & developer experience

  • Quick start (conceptual):
    • createDeepAgent(...) (or similar helper) wires planning, file tools, middleware and returns a compiled agent/runtime.
    • Define custom tools as Python functions with docstrings/type hints; the SDK turns those into tool specs sent to the model.
  • Schema and validation
    • Docstrings + type hints (and Pydantic) get converted into JSON schema-like definitions so model outputs are validated and properly parsed.
  • Observability & traces
    • LangGraph/DeepAgents provide traces of model/tool calls — essential for debugging and harness engineering (“the tail is in the trace”).
  • Prompt engineering
    • DeepAgents emphasizes systematic prompt engineering inside the harness (system prompts, prompt caching, and middleware that can mutate prompts).

Examples, demos, and use cases showcased

  • Deep research agent (web search + long running research with UI and summary compaction)
  • Coding / code‑editing agents (file system, tests, iterative runs)
  • “Second brain” / notes, Obsidian-style workflows (ingest, organize, recall)
  • Content builder / social media drafting and style‑based generation tools
  • Text → SQL agent (convert natural language to SQL given schema, run queries, return results)
  • Triage automations: triaging GitHub issues/PRs, categorizing and labeling
  • General productivity: calendar, email automation (with human‑in‑the‑loop approvals)

Security, safety and governance

  • Principle: enforce boundaries at the tool/sandbox level — don’t rely on the LLM to self‑police.
  • Tool sandboxing and whitelists: restrict what tools can do (e.g., DB writes, email sends, destructive ops).
  • Human‑in‑the‑loop: require approval for sensitive tool calls (default for CLI can be "require approval" with incremental whitelisting).
  • Sandboxes for code execution: run in contained environments and validate outputs.
  • Auditing & traces: use detailed logs/traces to review agent behavior and iterate harness rules.

Notable insights & quotes

  • “Agent harness” — the practical extras around the model+tool loop that make a capable agent.
  • “Prompts power agents” — long, carefully crafted system prompts are a major part of agent behavior.
  • Claude Code’s system prompt example: ~16,000 words — demonstrates how much instruction can live outside the user message.
  • “The tail is in the trace” — inspecting traces of agent runs is essential to improving harnesses.
  • Give agents planning tools and file access and they behave more like effective people: plan, take notes, iterate, check work.

Recommendations / best practices (actionable)

  • Start small: build a minimal agent harness (planning + a small, trusted tool) and iterate.
  • Define tools with explicit docstrings and types (use Pydantic where helpful) so models can call tools reliably.
  • Use middleware for common cross‑cutting concerns: summarization, approval gates, retries, logging.
  • Use sub‑agents to parallelize and to isolate context for small subtasks.
  • Add prompt caching and summarization to control costs and avoid context overflow.
  • Enforce security at the tool/sandbox level and require human approval for destructive or sensitive actions.
  • Record and analyze traces — use them to find failure modes and improvements.

How to get started / resources

  • DeepAgents GitHub repo / docs (LangChain): the episode points listeners to the DeepAgents repo and examples (deep‑research, text‑to‑SQL, content builder).
  • Quickflow (from the episode): import/create agent, supply models and tools, call agent.invoke(...)
  • Check LangChain + LangGraph for the runtime and tooling the harness uses.
  • Use MCP servers to reuse tools from other teams or the community.
  • LangChain forum / community for questions and contributions (the guest recommended the project forum).
  • Look at the DeepAgents examples and the LangGraph dev UI or Jupyter notebook demos to inspect traces.

Where things are headed

  • Continued polishing toward 1.0: richer remote file backends (S3, DB), more durable deployments, expanded UI tooling (Agent Builder), and better harness primitives.
  • More sandboxing and robust code execution patterns, plus better tooling for harness engineering (automatic evaluation of traces).
  • Growing ecosystem of reusable MCP tools and community‑shared agent components.

If you want to reproduce anything from the episode, check the DeepAgents GitHub and the LangChain docs for the exact package name, current API (createDeepAgent / create_deep_agent), and installation/pip instructions — start by running the quick examples and inspecting the example notebooks/Dev UI to see traces and middleware in action.