Claim
When a long-horizon agent fails, the correct debugging artifact is a trace of what appeared in the model's context at each step. Code review cannot surface failures that originate from context decisions: what information was included, compressed, or omitted at each node.
Mechanism
Traditional software has a fixed relationship between code and behavior. The application's logic is entirely in the source. A bug in behavior traces to a bug in code, and code review can find it.
Agent applications break this relationship. The logic for how an agent behaves is distributed between written code and what appears in the model's context at each decision step. Tool selection, information compression, memory retrieval, and sub-task decomposition all happen at runtime from context, not from deterministic code paths. A code review of a failing agent will show correct code. The failure lives in what the model saw, not what the developer wrote.
Traces expose the actual input at each step: what the context window contained when the agent made a decision. This makes trace inspection the primary diagnostic tool for agent failures, the same role code review plays for traditional software.
Conditions
Holds when: the agent makes multi-step decisions over a long horizon where each step's input depends on the outputs and retrieval decisions of prior steps. Failures compound across steps and are invisible to static analysis.
Fails when: the agent is a thin wrapper with minimal context manipulation, or when the bug originates from a deterministic code error (wrong tool implementation, incorrect parsing) rather than a context decision. In those cases, code review still locates the failure.
Evidence
Harrison Chase spoke at the Sequoia Capital podcast on September 3, 2026 about patterns he has observed across teams building long-horizon agents with LangChain. He named trace inspection as the emerging standard debugging workflow:
"Everything's context engineering"
"Building agents is different than building software"
On the practical shift in how teams debug: teams working on long-horizon agent failures now ask for traces rather than source code, because the relevant information about what went wrong is in the context at each decision point, not in the code itself.
"Traces just tell you what's in your context. And that's so important."
Signals
- A team debugging an agent failure asks "what was in the context at step N" before asking "what does the code do."
- Adding more explicit context at a failing step resolves the failure without any code change.
- Two identical code deployments produce different agent behavior based on what information was retrieved or compressed at runtime.
Counter-evidence
Trace inspection is nascent as a debugging discipline. Most observability tooling is designed for traditional software and does not natively represent multi-step context state. Teams without LangSmith or equivalent tooling cannot easily generate or read traces. Chase's framework reflects LangChain's use cases, which skew toward customer-facing agents with many steps; simpler single-turn agents may not exhibit the code/context split he describes.
Cross-references
- (none in current corpus)