The Compounding Problem
If an agent makes the right decision 95% of the time at each step, after 10 steps the probability of a fully correct outcome is 0.95^10, which is about 60%. After 20 steps, it drops to 36%. The math is unforgiving. Even small error rates compound into significant failure rates over multi-step tasks.
This is why agents that work well on simple three-step tasks can fail reliably on ten-step tasks. The model's per-step accuracy hasn't changed, but the number of steps has increased enough for compounding errors to dominate the outcome.
Context Drift
As an agent works through a multi-step task, the accumulated context grows and shifts. By step 15, the original task description is buried under pages of tool results, intermediate reasoning, and error handling. The agent can lose track of its original goal, subtly reinterpreting the task based on whatever information is most recent in its context.
This is called context drift, and it's one of the most common failure modes for long-running agents. The agent starts out pursuing the correct goal but gradually shifts to pursuing a related but different goal based on the information it encounters along the way.
Mitigation strategies include periodically restating the original goal in the context, using working memory to maintain a clear task description separate from the conversation flow, and implementing explicit checkpoints where the agent compares its current direction against the original objective.
Error Cascades
When an agent makes a mistake at step 3 and doesn't catch it, the mistake propagates through all subsequent steps. If the agent queries the wrong database table and uses those results to make decisions at steps 4 through 10, all of those decisions are based on incorrect information. The final output might look plausible but be fundamentally wrong.
Error cascades are particularly dangerous because the agent often has no way to detect them. The tool calls succeed, the results look reasonable, and the logic appears sound. The only problem is that the foundation was wrong. This is why agents that can verify their intermediate results (by checking against independent sources, running validation tests, or cross-referencing data) produce more reliable outputs than those that blindly trust each step's results.
Planning Failures
Complex tasks require planning: breaking the overall goal into subtasks, ordering those subtasks logically, and identifying dependencies between them. Current language models can plan, but their planning ability degrades for tasks with many dependencies or non-obvious orderings.
A common failure mode is the agent diving into execution without adequate planning, then discovering partway through that it needs information from a step it hasn't taken yet. Backtracking is possible but expensive in terms of tokens and often produces awkward results as the agent tries to incorporate new information into a partially completed plan.
Frameworks that separate planning from execution tend to produce better results for complex tasks. The agent first generates a plan, which can be reviewed (by a human or by a second model), and then executes the approved plan. This catches planning errors before they lead to wasted execution.
Tool Selection Errors
With multiple MCP servers connected, an agent needs to choose the right tool for each step. This selection is based on tool descriptions and the agent's understanding of its current need. When the agent picks the wrong tool, the result might be a clear error (which is easy to handle) or a subtly incorrect result (which is dangerous because it looks right).
Tool selection accuracy improves with better tool descriptions. If an MCP server's tools are described clearly and specifically, the model is more likely to choose the right one. Vague descriptions like "process data" are much less helpful than specific ones like "run a SQL query against a PostgreSQL database and return results as JSON."
Building More Reliable Agents
Several strategies improve agent reliability on multi-step tasks. Decomposition: break complex tasks into simpler subtasks that each have a high success rate. Verification: check intermediate results before building on them. Fallback strategies: define what the agent should do when it encounters unexpected situations. Human checkpoints: pause for confirmation before executing irreversible or high-impact actions.
Monitoring agent behavior during development is also valuable. If you can identify which steps fail most frequently, you can improve the prompting, tool descriptions, or error handling for those specific steps. Reducing failures also reduces costs, since failed attempts consume tokens without producing value.