Deep Agents in Action: Building a Multi-Agent Research System (published)

Fri, 25 Sep 2026 14:39:24 +0000

I tested yet another implementation of a multi-agent orchestrator.

The paradigm for AI agents is shifting rapidly from single, monolithic prompt loops to structured multi-agent systems capable of division of labor, state persistence, and fine-grained tool orchestration.

Although IBM watsonx Orchestrate is my go-to solution for enterprise-level agent deployment, I wanted to experiment with LangChain's Deep Agents to evaluate its multi-agent orchestration capabilities.

Introduction: The Deep Agents Architecture

LangChain announced recently Managed Deep Agents, introducing a managed platform to execute deep agent topologies. The Deep Agents paradigm addresses the fundamental limitations of single-agent workflows—specifically context window degradation, tool confusion, and compounding reasoning failures during extended, multi-step tasks.

What is the Deep Agents Pattern?

The Deep Agents pattern is a hierarchical multi-agent architecture where:

A top-level Orchestrator decomposes complex tasks and delegates sub-tasks to specialists.
Each Specialist Agent runs its own isolated ReAct loop with its own tools and memory.
Specialists return structured results to the orchestrator, which synthesises them.
Agents can be composed recursively — an orchestrator can itself be a sub-agent.
This pattern adds genuine value over a single agent because:

| Single Agent                       | Deep Agents                                       |
| ---------------------------------- | ------------------------------------------------- |
| One context window gets overloaded | Each agent has an isolated, focused context       |
| All reasoning in one prompt        | Specialised reasoning per domain                  |
| Hard to scale                      | Add specialists without changing the orchestrator |
| Hard to debug                      | Full delegation trace for auditability            |

---

Excerpt from LangChain Deep Agents Documention;

Deep Agents overview

Deep Agents is the easiest way to start building agents and applications that are powered by LLMs—with built-in capabilities for file systems for context management, subagent-spawning, and long-term memory. Optional capabilities such as task planning and skills extend the harness when your use case needs them. You can use deep agents for any task, including complex, multi-step tasks.Deep Agents comes with the following capabilities:

Take actions in an environment: Take actions via tools, read and
write files, execute code
Connect to your data: Load memories,
skills, and domain knowledge at the right moment
Manage growing context: Summarize history and offload large results across long runs
Parallelize tasks: Delegate to general or specialized subagents running in isolated context windows
Stay in the loop: Pause for human approval at critical decision points Improve over time: Update memory, skills, and prompts based on real usage

And from the Github repository;

Deep Agents is an open source agent harness — an opinionated agent that runs out of the box. Extend, override, or replace any piece.

Principles:

Opinionated — defaults tuned for long-horizon, multi-step work
Extensible — override or replace any piece without forking
Model-agnostic — works with any LLM that supports tool calling: frontier, open-weight, or local
Production-ready — built on LangGraph (streaming, persistence, checkpointing) with first-class tracing,
evaluation, and deployment via LangSmith

Features include:

Sub-agents — delegate tasks to agents with isolated context windows
Filesystem — read, write, edit, or search over pluggable local,
sandboxed, or remote backends
Context management — summarize long threads and offload tool outputs
to disk
Shell access — run commands in your sandbox of choice
Persistent memory — pluggable state and store backends for
cross-session recall
Human-in-the-loop — approve, edit, or reject tool calls before they
run
Skills — reusable behaviors the agent can load on demand
Tools — bring your own functions or any MCP server

Core Concepts of LangChain Deep Agents

Hierarchical Orchestration: A primary agent acts as a supervisor,
receiving high-level goals and delegating sub-tasks to dedicated
specialist agents rather than executing every step sequentially in a
single context loop.
Specialized Agent Roles: Individual agents operate with tightly
scoped system prompts, specialized tools, and isolated context
windows to execute sub-tasks (e.g., information retrieval, numeric
calculations, or document composition).
Isolated Memory Stores: Each agent maintains its own short-term
working memory, facts, and episodic memory, preventing state
contamination across different phases of execution.
ReAct Reasoning Loop: Sub-agents execute autonomous Thought → Action
→ Observation loops using validated tool interfaces.

Technical Implementation

Now that the feature set of "Deep Agents" is done, let's jump into a simple didatical (for myself) implementation.

The implementation in the provided repository (scaffolded via IBM Bob) provides a complete local and cloud-compatible implementation of the Deep Agents pattern.