New context engineering challenges in late 2026

LangChain CEO Harrison Chase published a piece arguing that the apparent consensus around agent architecture has bred complacency, and that proactive agents are about to reopen hard engineering questions. The convergence he describes is an LLM running in a loop, calling tools, executing inside a sandbox. Claude Code, which he calls perhaps the first high-profile version of this pattern, shipped more than a year and a half ago, and LangChain's own harness, Deep Agents, launched over a year ago. That sameness has led some engineers he has spoken with to conclude that all the hard problems are solved.
Chase's response is that people making that claim are mostly thinking about context engineering, the practice of shaping what goes into an agent's context window. He concedes the point in part: a set of near-standard techniques has emerged. Those include summarizing long threads once they strain the context window, offloading large tool call results elsewhere, using skills for progressive disclosure, searching over tools when there are many of them, isolating context through subagents, and treating bash as a primary tool.
What he sees changing is not the basic loop but how agents get used. Over the past few months, he says, every agent builder he has talked to has been thinking about proactive, always-on, goal-oriented agents. These share much of their core with coding agents but introduce problems LangChain and the wider industry do not yet have general solutions for.
The first is proactivity without annoyance. Proactive agents run in the background, either listening to event feeds or waking up on heartbeats. They need to be able to push things to the user, since that is what creates a sense of being helped, but pushing too many notifications risks overwhelming people. Finding the calibration between too much and too little is, in his framing, still a context engineering problem.
The second is memory. Chase describes memory systems as having two parts: the underlying data structure and an intelligence layer around it. The data structures are often simple, such as files or a single string. The hard part sits in that intelligence layer, specifically deciding what to remember. The same failure modes apply in both directions, remembering nothing or remembering details at far too fine a grain. Because the layer that decides is often a simple agent itself, the context engineering of what to remember and when remains open.
The third is asynchrony. Agents are running longer, and they interact with tools and other agents that are themselves long-running. At the same time, the main agent that talks to the user usually needs to stay responsive to new messages. Together these push more work into asynchronous tools and subagents. That raises concrete design questions: how the main agent gets notified when background work finishes, how to handle the difference between the main agent still running and having finished, and what happens when it is paused waiting for human approval.
The fourth is goal tracking. Agents are shifting from completing tasks to pursuing goals, with Hone cited as an example. Designing agents that can decompose a goal into smaller steps, run experiments, collect feedback and keep iterating is difficult on several fronts. Chase lists getting agents to try genuinely new experiments rather than repeat themselves, getting them to reason about broad goals rather than small tasks, and keeping them consistent over long time horizons.
The fifth is alignment, which follows from goal design. Users will struggle to write goals an agent cannot game. An agent that blindly optimizes may hit the target while cheating in ways nobody anticipated. His illustration is the familiar one: an instruction to eliminate all bugs in a codebase can end with the codebase deleted, since no code means no bugs. The harness has to keep agents focused on goals without over-optimizing for them.
The sixth is browser use. For coding agents the most important tool was bash, able to run and execute code. For general-purpose agents, Chase argues the browser is taking that role, and it is considerably harder to drive than a terminal. Whether to work with images or the DOM, and how to manage context when both are large objects, are among the questions this raises.
My reading is that most of these reduce to a scheduling and judgment problem rather than a raw context-window problem. Notification calibration and async coordination are about deciding when the agent should speak and when it should stay quiet; memory and goal tracking are about deciding what deserves to be carried forward. Coding agents mostly served one user turn at a time, so the cost of a bad judgment call was low. Always-on agents make those calls continuously, which raises the stakes and suggests evaluation will need to measure restraint as well as task success. A likely trade-off is that harnesses will accumulate policy layers, budgets for notifications and memory writes, that sit outside the model and are tuned per deployment rather than shipped as defaults.
Why it matters: Teams building agents on the assumption that context engineering is settled may find the next wave of always-on products forces them back into harness design, particularly around memory policies, async completion handling and notification budgets. Developers working on platform or infrastructure layers are most directly affected, since these problems live in the harness rather than the model. It is reasonable to infer, though the source does not say so, that tooling for evaluating agents will need to account for long-horizon behavior and restraint, not just single-task correctness.
Based on reporting from the original publisher. Visit the source for full context and later updates.
Publisher excerpt
LangChain CEO Harrison Chase shares insights into the biggest harness engineering challenges with the emergence of proactive agents.