What Are Deep Agents? Shallow Agents Vs Deep Agents

Deep agents are built for complex, multi-step work that shallow agent loops struggle to handle—by adding explicit planning, task decomposition into sub-agents, shared system instructions, and persistent memory. Instead of sending a single query to an LLM and letting it decide whether to call a tool, deep agents run a structured workflow that can coordinate research, writing, verification, and other steps in parallel.

In the most basic “shallow agent” setup, an LLM acts like a decision layer: it either generates an answer directly or calls external tools (weather APIs, search APIs, database tools, and similar services) to fetch missing information. That produces a simple request → tool → output loop. The limitation is that there’s no explicit planning stage and no robust context retention across steps. For straightforward questions—like retrieving the current temperature of a city—this works well. But for complex requests (such as compiling today’s AI news and tying it to economics and physics), the task needs decomposition into sub-questions and coordinated execution, which the shallow loop doesn’t handle reliably.

A step up is the ReAct-style agent pattern, where the LLM can alternate between reasoning and acting. The model receives a system prompt, chooses among multiple tools, and then uses tool observations as context for further tool calls. This enables multi-step problem solving, and the loop can run repeatedly until a final answer emerges. Yet it still lacks deeper structure: it’s essentially LLM + tools operating in a continuous cycle, without explicit planning artifacts, state management, or persistent memory shared across steps.

Deep agents change the architecture. They’re described as having four core components: (1) a planning tool that converts the user request into a to-do list, (2) sub-agents that execute each planned step, (3) a system prompt that governs how the agent(s) should behave, and (4) a file system that acts as persistent memory accessible to all sub-agents. The planning stage is the key shift—turning a vague goal into an ordered set of tasks that can be assigned and tracked.

A concrete example uses a Cloud Code deep research workflow. The system prompt instructs the assistant to behave as an interactive CLI tool for software engineering tasks and to refuse malicious code. When given a travel-planning request (e.g., booking a Paris trip within a budget and duration), the deep agent first produces a day-by-day to-do list (travel, lodging, activities, return). It then spawns sub-agents to execute each item. The shared file system lets sub-agents store and retrieve intermediate results so the overall effort stays coherent.

The same structure applies to content workflows. For a blog request, a deep research agent can plan tasks like researching the topic, doing additional research from papers or other sources, drafting the blog, and running a copyright check. Sub-agents can work in parallel—one focused on internet research, another on archive/paper sources, another on writing, and another on compliance checks—before producing a consolidated final output.

Finally, the transcript outlines an implementation approach using an open-source library called “LangChain” examples and an “agents” library (referred to as “D agents” in the narration). It demonstrates creating a deep agent by defining tools (such as an internet search tool using Tavily), providing a system prompt, selecting a model, and invoking the agent to perform streaming deep research results. The tradeoff is time: deep agents take longer, but they generate more complete multi-step outputs suited to complex tasks.