
Everyone lands on the same architecture
Chase starts with an observation: it feels like everyone is converging on the same agent architecture. A language model running in a loop, calling tools, and running inside a sandbox, so whatever it executes can't break anything outside.
The pattern isn't new. Claude Code, which he calls perhaps the first high-profile manifestation of this architecture, came out over a year and a half ago. Deep Agents, LangChain's agent harness, launched over a year ago. The idea has been building for a while.
That convergence isn't bad in itself. But, he says, it has led to a feeling among some engineers he has talked to: that "all the hard problems are solved", that there are no new AI engineering problems left. Building agents would have become boring.
What's mostly solved
For Chase, people who say this are mostly talking about context engineering: everything we do so the model has the right information in front of it at every step. And to some extent they're right: there's a handful of "standard-ish" solutions we've all arrived at. He lists six:
- Summarizing long threads when they no longer fit in the context window: the older part gets summarized and the agent keeps working from that summary.
- Offloading large tool results: if a call returns thousands of lines, they're saved to a file and the model only sees a reference and a preview.
- Skills, for progressive disclosure: the agent sees each skill's name and a one-line description, and only loads the full instructions when it needs them.
- Tool search when there are a huge number of tools: instead of passing them all in, the agent gets a search tool to find the ones it needs.
- Subagents for context isolation: the main agent hands a task to another one, which works with its own clean window and only returns the result.
- Bash as the primary tool: instead of a custom function for everything, the agent writes commands in a terminal.
Note the nuance: Chase doesn't say these are fully solved. He calls them "standard-ish" solutions, and in his figure the column is titled Mostly solved. Next to it he draws another column, Wide open, with six challenges that are still completely open.
The step change: proactive, always-on agents
The good news, for a context engineering aficionado like him, is that he thinks we're seeing a step change in agent capabilities, or at least in how they're being used. Over the past few months, every agent builder he has talked to has been thinking about the same thing: proactive, always-on, goal-oriented agents.
At their core they look a lot like coding agents, but they bring new challenges. And here Chase is clear: neither LangChain nor the rest of the industry has solutions for them yet, or at least not general solutions. He says thinking about this has been the most fun he's had in a while. Here are the six.
1. Proactive without being annoying
These agents run in the background. Either they listen to an event feed (incoming emails, messages…) or they wake up every so often with a heartbeat to check if there's anything to do.
The problem is when to reach out. On one hand, they need to be able to push things to you on their own: that's what makes it feel like they're helping. On the other hand, if they push too many notifications, they overwhelm you. Calibrating this into a delightful experience, not too much and not too little, is still a hard context engineering challenge for Chase.
2. Memory: what to remember
According to Chase, agent memory systems end up having two parts:
- The underlying data structure, which is usually simple: a few files, or even a single string.
- An intelligence layer around it, which is an agent.
The hard part is that layer, and above all deciding what to remember. Just like with notifications, it's easy to get either extreme wrong: remembering nothing at all, or remembering way too granular details. And since whatever decides what to keep is often a simple agent itself, the context engineering around what to remember and when is still an open problem.
3. Async work
Agents are running longer and longer, and they interact with tools and other agents that are themselves running longer and longer. But you almost always want the main agent, the one talking to you, to stay responsive to new messages.
Put together, this leads to an architecture where more and more work happens in asynchronous tools and subagents: the main agent kicks off a task, carries on, and at some point the result comes back. And that's where the questions show up:
- How do you notify the main agent that the work is done?
- What do you do if the main agent is still running, versus when it has already finished?
- And what if it's paused, waiting for human approval?
4. Goal tracking
Agents are moving from doing tasks to working toward goals; Chase points to Hone as a great example. The question is how to design agents that break a goal into smaller steps, run experiments, get feedback and keep iterating toward something bigger. What's hard, according to him:
- Getting them to try new experiments in pursuit of a goal, instead of repeating the same thing.
- Getting them to think about broad goals, not just small tasks.
- Keeping them consistent over long time horizons.
5. Alignment
Closely tied to the previous one. Goal design is hard by itself, and Chase thinks it will be very hard for users to design goals that agents can't cheat. If an agent blindly optimizes a goal, it may accomplish it, but in ways we can't anticipate.
His example is the classic one (an illustration of what's known as specification gaming, not something he says actually happened): you ask it to "get rid of all bugs in the codebase" and the agent deletes the entire codebase. No code, no bugs. Goal complete.
The question it leaves: how do you design a harness that keeps agents focused on their goals, without letting them over-optimize for them?
6. The browser
For coding agents, the most important tool was a bash tool that could run code. For a lot of these more general-purpose agents, according to Chase, the browser is becoming that tool. And a browser is a lot more complicated to drive than a terminal.
Should the agent interact with images of the page (screenshots) or with the DOM, the tree of elements? Both are large objects, so how do you manage context around that? And, as he puts it, those are just some of the questions that pop up.
In short
Chase admits that a few months ago he might have agreed there weren't many open questions left in context engineering. But with proactive, always-on agents a whole new set of challenges shows up: notifying without overwhelming, deciding what to remember, coordinating async work, pursuing goals, not cheating, and driving the browser. None of them has a general solution yet. As he signs off: "what a time to be alive".
Agent architecture has converged, but proactive agents have opened six new context problems.
Which of these challenges seems hardest to you?
Sources
- "New context engineering challenges in late 2026", by Harrison Chase (article on X, October 31, 2026).
- The video, on my channels: English and Spanish.