The Context at Step 14 Isn't in the Code

Sonya Huang reminds Harrison Chase that he was Training Data's first guest, and that eighteen months later the industry has already turned over several times. Chase is happy to be back; he will tell his mom again. Sequoia had just published a post naming this wave long-horizon agents: give the system a task and it can run for hours or days. Chase agrees the framing is right, and that the underlying idea is not new.

Running an LLM in a loop and letting it decide what to do was the agent concept from the start, which is why AutoGPT captured so many imaginations. It did not last, because the models were not good enough and the scaffolding around them was not good enough either. Models improved, the industry learned what a good harness looks like, and the pattern started to work—first in coding, then spreading outward. You still have to tell the agent what you want and give it the right tools, but it can operate for longer and longer stretches.

Chase is clear-eyed about reliability. Agents are nowhere near nine-nines. They can do a huge amount of work over long horizons, but someone still has to look at the result. That is why the applications he likes share a shape: they produce a first draft. Coding agents open a pull request instead of pushing to production. Traversal, a Sequoia company, runs an AI SRE that digs through logs and surfaces a report for a human. Research and report generation in finance follow the same pattern. In customer support, Klarna is the example he cites: when first-line AI fails, a long-horizon agent compiles what happened and hands a brief to the human who takes over.

Pat Grady asks how much of the "why now" is better models versus smarter harness work. Chase splits the stack into three layers. The model is the LLM: messages in, messages out. A framework is the abstraction layer around it—swap models, attach tools, vector stores, memory—without taking a strong view of what should live inside. That is how LangChain described itself early on. A harness is batteries-included. Deep Agents, built on LangGraph, ships a planning tool by default. That is an opinion: long tasks should plan first.

Harnesses and models are co-evolving. Two years ago, nobody could have known that file-system harnesses would win, because models were not being trained on that data the way they are now. OpenAI trains heavily on Bash. Anthropic fine-tunes dedicated file-editing tools. The same way prompts used to differ by model, harnesses now need to differ by model family. Compaction is part of the harness too: context windows are larger but not infinite, and long-horizon runs fill them up.

Chase thinks a lot of Claude Code's popularity is the harness itself, not only the model. Terminal-Bench 2.0 lists harness and model separately, and Claude Code is not at the top. Coding-product companies are almost all building their own harnesses; he specifically praises Factory and Amp. The hard part is the glue. When a main agent spawns a sub-agent, only the final reply comes back. LangChain has watched a sub-agent do a pile of work, then say "look at my work above"—which the parent cannot see. The hundreds of lines of prompts inside a harness exist to teach those pieces how to hand off.

Grady offers a simple history of the last five years: ChatGPT as the pre-training inflection, o1 as the reasoning inflection, Claude Code and Opus 4.5 as the long-horizon one. He asks Chase for the equivalent timeline on the engineering around the model. Chase describes three eras. First, when LangChain started, models were raw text-in, text-out: no tool calling, no content blocks, no reasoning. People wrote single prompts and simple chains because nothing more complicated was possible.

Second, labs trained tool calling into the models. The systems could sort of decide what to do, but they were not smart enough to run free. That is when custom cognitive architectures mattered: you asked the model explicitly what to do at a branch, then another branch, maybe a loop, and the scaffolding got thicker. Third era, Chase dates to around June and July of 2025. Claude Code, Deep Research, and Manus all took off on the same core algorithm—an LLM running in a loop—with the gains in context engineering: compaction, sub-agents, skills. That is when LangChain started Deep Agents.

The coding community felt it a bit later. Opus 4.5 landed near winter break; people went home, used Claude Code heavily, and discovered it could chew on hard problems. By November and December he sensed a vibe shift. His summary: at some point in 2025 the models got good enough, "and that's when we moved from scaffolds to harnesses." What is next is handing more of the manual pieces to the model itself. Compaction is still designed by the harness author; Anthropic has experiments that let the model decide when to compact, though Chase does not see many people using them yet. Memory, in this frame, is context engineering over a longer clock.

Most of the harnesses Chase sees are coding-specific, which is also where long-horizon agents first took off. Grady asks the question the industry has been circling: are coding agents a subcategory, or are they just agents—because the job of an agent is to get a computer to do useful work, and code is a good way to do that? Chase does not pretend to have a clean answer. It is one of the biggest things LangChain is thinking about.

He is unequivocal on one point: if you are building a long-horizon agent right now, you need to give it a file system. Compaction can summarize while parking the original messages on disk so the agent can look them up. Large tool results should not all go into the model; write them to files and let the agent retrieve. You can fake that with a virtual file system backed by Postgres, which is more scalable, but you cannot run code in a virtual file system. Writing scripts still has no substitute for the long tail of tasks.

A coding agent can be general purpose. That does not mean today's coding agents are. They are optimized for coding tasks. Chase's formulation is careful: it is possible that a general-purpose agent *is* a coding agent, and he is not sure the reverse is true.

"Building agents is different from building software" is a line Chase has heard so often he used to roll his eyes. He wrote a post to pin down what is actually different. In software, the logic lives in the code; you can read it and know what the program will do. In an agent, a large part of the logic lives in the model's billions of parameters. You cannot look at the repo and know what the system will do in a given scenario. You have to run it. That is the non-determinism, and it is the biggest difference.

That is why traces dominate agent development in a way logs never dominated software. Software logs are something you turn on in production, after an error; locally you set a breakpoint. Agent teams use traces from day one. In a single LLM call you know the prompt and the context because code assembled them. In an agent, you do not know what is in context at step 14, because the thirteen steps before it may have pulled in anything. "Context engineering is such a good term," Chase says. "I wish I came up with that term." It describes everything LangChain has done, before the phrase existed. Traces are how you see what is actually in context.

The source of truth for software is code. For agents it is code plus traces. Test cases get built from traces; online testing matters more than offline, because behavior does not show up until real inputs arrive. Collaboration moved with it. When Deep Agents goes off the rails, LangChain's reply to open-source users is no longer "show us the code." It is "send us a LangSmith trace." Iteration is different too. You know what software does before you ship it; you iterate on whether users want that. You do not know what an agent does before you ship it. Developers change the system prompt far more often than they change code, which is why Chase cares about memory: if the system can learn from interactions, it cuts down that loop.

On who builds this work, Chase sees a younger skew. LangChain's applied AI team leans young, and agent-engineering teams elsewhere are often more junior builders without old-software preconceptions. Plenty of senior developers have adopted agentic coding—Huang even got Grady onto Claude Code—so he treats it as a mindset more than an age limit. For existing software companies, data and APIs are the asset that is going up in value. A finance contact told him data's value keeps rising. What is net new is the *instructions* for how to use that data: the work humans used to do, which vendors never consolidated. Vertical teams like Rogo, who bring finance knowledge into agents, move faster because agent quality is driven by knowledge of specific patterns, not world knowledge.

Software tests rest on assertions a machine can check. Agents do work humans used to do, so judging them requires human judgment. LangSmith's job, in Chase's telling, is to bring that judgment onto the trace: annotation queues where people mark a trajectory good or bad, leave natural-language feedback, or lay out the correct steps. Data-labeling startups have been doing well for the same reason. Pure human labeling does not scale, so teams build LLM-as-judge proxies. Those proxies are worthless if they are not calibrated to the humans. LangSmith's Align Evals flow has a person label traces, then builds a judge against that set.

The more interesting use of evals, for Chase, is not reinforcement learning at application companies. It is handing traces to a coding agent. LangSmith ships an MCP server and a CLI called LangSmith Fetch, because coding agents are good at CLIs. Point Claude Code at it, pull down a failing trace, diagnose what went wrong, and patch the repo. A human still reviews the prompt change, which is the same first-draft pattern: keep it on the rails. Chase is more bullish on that loop than on RL for agent-app companies right now.

LangSmith Agent Builder pushes the idea further. It is a no-code way to build agents with memory. If you tell the agent "next time do Y instead of X," it edits its own instruction files. Chase wants a nightly job that reads the day's traces and updates those instructions—sleep-time compute, a term he attributes to Letta. Daytime work, nighttime review. He is cooler on ChatGPT-style memory: he barely uses it, because his ChatGPT questions are one-offs about software, food, and trips. Workflows reverse the conclusion. He had an email agent, running for two years, that kept emailing Huang. Moving it into Agent Builder kept the starter prompt and the tools and dropped the memories. He still has not fully switched, because the new one "kind of sucks" until he retrains it through use. That, he says, is a real moat.

If a task runs for a day, nobody sits and waits. Chase thinks long-horizon agents need an async management surface—Linear, Jira, kanban boards, even email as inspiration—so you can kick off several jobs at once. They also need a sync mode. When the agent comes back with a research report and something is wrong, you want a chat. Many of these agents now modify files, so you also need a way to *see* the state, the way developers still open an IDE after Claude Code finishes and inspect what it wrote.

Anthropic's Claude Cowork made that concrete: you pick a directory and tell the agent "this is your environment." The workspace could be a Google Drive, a Notion page, anything that stores state. You and the agent collaborate on that state—async dispatch, sync chat, plus a view of what changed. LangChain shipped Agent Inbox about a year ago for ambient agents that ping you. The first version was async only: the agent messages, you reply, then you wait. Opening the inbox now drops you into chat. That single sync entry point was a big unlock. Chase does not think a pure async mode works yet. People bounce between the two. Maybe later, if agents need less correction, async becomes enough.

On the standard kit—sandbox, computer, browser—he ranks the pieces. He is fully "file system pilled": long-horizon agents should have a file system in some form. Code execution he is about 90 percent there; repeated tasks may need it less, but the long tail has no replacement for writing scripts. Browser use is the weak one: from what LangChain has seen, the models are not good enough yet, though you can approximate it by giving a coding agent a CLI. Computer use sits in between as a hybrid. Huang closes by crediting Chase with seeing the agent future early. Chase's last line is the honest one: he looks forward to coming back and being completely wrong about everything he said today.