Shallow agents fail at step 20, deep agents plan and remember
The prompt, tool, result loop works for 5 to 15 steps and collapses on real work. Deep agents add explicit planning, delegation to sub-agents, persistent memory and heavy context engineering.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 2 December 2025 Updated: 2 min read
Your agent crushed the demo. You asked it to build a REST API with authentication, database schema, tests, and documentation.
By step 23, it forgot what it was doing. By step 40, it was down a rabbit hole you couldn’t pull it out of.
That is Agent 1.0 architecture. Great for “What’s the weather in Tokyo?” Useless for real work.
How Agent 1.0 works
Most teams use the same architecture: prompt, then LLM, then tool, then result, then repeat. A loop, a context window, and hope.
The agent’s entire “brain” lives in the conversation history. No external state, no memory: stateless and ephemeral.
That is fine for 5 to 15 step tasks like “What’s the stock price?” It is not enough for real work.
Where it collapses
Tasks of 50 steps or more fail predictably:
- Context overflow: tool outputs fill the window, the instructions get pushed out, and the agent works blind.
- Loss of goal: it forgets the original objective amid the intermediate steps.
- No recovery: it can’t backtrack, so it pushes forward until it crashes.
5 to 15 steps work. 500 steps fail. You need 500.
Agent 2.0: four pillars of deep agents
Production teams are moving to Agent 2.0, also called deep agents. It rests on four pillars.
Explicit planning
Agent 1.0 plans implicitly, in its chain of thought. Agent 2.0 creates to-do lists: markdown files updated between steps. The external plan is the source of truth.
Hierarchical delegation
Agent 1.0 is one agent doing everything. In Agent 2.0, an orchestrator delegates to sub-agents (researcher, coder, writer). Five agents with 10 steps each beat one agent with 50.
Persistent memory
Agent 1.0’s memory is the context window. Agent 2.0 uses the filesystem or a vector database and writes intermediate results there. The shift is from “remembering everything” to “knowing where to find it.”
Extreme context engineering
Smarter models need better context, not less. Agent 2.0 uses detailed instructions that define when to plan, the protocols for sub-agents, tool examples and naming standards. The architecture scales, not the model.
The step wall is an architecture limit
Agent 1.0 is stateless, manages 5 to 15 steps, and runs in demo mode. Agent 2.0 combines planning, delegation and memory, and runs in production mode.
If your agent fails after 15 to 20 steps, you have hit an architectural limit, not a model limit. Redesign the system.
Most teams build Agent 1.0 without knowing it, and mistake architectural limits for AI limits. Teams who redesign will ship production agents. Teams who don’t will keep debugging while loops.
Are your agents hitting the 15 to 20 step wall, or have you already moved to Agent 2.0 architecture?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Coding agent setup
- Slash commands, MCP, sub-agents and skills form a hierarchy Teams build the same workflow three ways because they treat Claude Code's four overlapping features as equals. They form layers: prompts at the base, MCP and sub-agents beside each other, skills composing the rest.
- One general agent with a skill library beats 47 custom agents Teams cram every procedure into monolithic agent prompts. Agent Skills replace them with one general agent and a composable library that loads knowledge in layers.
- Use subagents as researchers, not implementers Subagents that implement directly lose context between sessions. Subagents that research, write their plans to the file system and leave the implementation to the main agent work in production.
Test the constraint in your system
The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check