The 6 open challenges in context engineering (Harrison Chase)

The 6 open challenges in context engineering (Harrison Chase)
6context techniques that are now standard-ish
6challenges that, according to Chase, are still wide open
1.5+ yearssince Claude Code came out, perhaps the first high-profile example of this architecture
6 open challenges for AI agents (Harrison Chase, LangChain)
I also explain it in this video, on my channel Articulator EN. The figures in this post are frames from the video.

Everyone lands on the same architecturelink

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.

An agent's loop: the model thinks, calls a tool, looks at the result and starts again, inside a sandbox
The architecture everyone is converging on.
A language model running in a loop, calling tools inside a sandbox
The architecture everyone is landing on: a model in a loop, tools and a sandbox.

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 solvedlink

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.

Two columns: mostly solved (summarization, offloading tool results, skills, tool search, subagents, bash) and wide open (proactive not annoying, what to remember, async work, goal tracking, alignment, browser use)
The article's figure, redrawn: six pretty much standard techniques and six open challenges.
Two columns: six mostly solved techniques and six wide-open challenges
The article's figure, redrawn: six standard-ish techniques versus six open challenges.

The step change: proactive, always-on agentslink

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 annoyinglink

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.

A phone full of notifications from an agent
Too many notifications overwhelm you: the challenge is finding the sweet spot.
A proactive agent that sends too many notifications and overwhelms the user
Not so few notifications that it doesn't feel helpful, not so many that it overwhelms.

2. Memory: what to rememberlink

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.

Memory in two parts: a simple data structure and an intelligence layer, an agent, that decides what to keep
The two parts of a memory system.
An agent's memory: a simple data structure and an agent that decides what to keep
The structure is simple; the hard part is deciding what goes into it.

3. Async worklink

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?
Timeline: the main agent running, done and paused waiting on the user, with a subagent and an async tool returning their result
The timeline figure, redrawn: how do you notify the main agent in each case?
Timeline: the main agent running, done and paused, and results from a subagent and an async tool coming back
The article's diagram, redrawn: a result can come back while the main agent is running, after it's done, or while it's waiting on you.

4. Goal trackinglink

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. Alignmentlink

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.

Terminal: goal: get rid of all bugs in the codebase, rm -rf src/, npm test, 0 bugs found, goal complete
The classic example: no code, no bugs.
Terminal: goal get rid of all bugs, the agent deletes the code and reports zero bugs
The classic example: the goal is met to the letter, and the code is gone.

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 browserlink

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.

A screenshot next to the DOM tree, both too big for the context
Screenshots or the DOM? Both are huge objects.
A web page: screenshots or the tree of elements?
Screenshots or DOM? Both are huge for the context window.

In shortlink

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".

In one sentence

Agent architecture has converged, but proactive agents have opened six new context problems.

Which of these challenges seems hardest to you?

Sourceslink

Continue reading

Last posts -->

Have you seen these projects?

Gymnasia

Gymnasia Gymnasia
Expo
React Native
TypeScript
OpenAI
Anthropic

Fitness app with two agents that run entirely on the device, with no backend, so the user's data never leaves the phone. A BYOK conversational coach with local tools and a remote system prompt with offline fallback, plus a food estimator that pulls macronutrients out of a photo of the plate, with barcode scanning against OpenFoodFacts.

LangGraph Deep Researcher

LangGraph Deep Researcher LangGraph Deep Researcher
Python
LangGraph
FastAPI
React
TypeScript
Docker

Multi-agent research system built with LangGraph. A supervisor breaks your question down into topics and launches search sub-agents in parallel; each one compresses its findings before handing them to a writer agent that produces the final sourced markdown report. Live streaming over WebSockets, a configurable model per role and bring-your-own API keys that are never persisted server-side.

Tau

Tau Tau
Python
LangChain

Multi-agent tutoring system for secondary school students, with one agent per subject and course material written and validated by a team of teachers. It was used with real students at a private school in Spain and at a secondary school in Colombia.

View all projects -->
>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Do you want to watch any talk?

Last talks -->

Do you want to improve with these tips?

Last tips -->

Use this locally

Hugging Face spaces allow us to run models with very simple demos, but what if the demo breaks? Or if the user deletes it? That's why I've created docker containers with some interesting spaces, to be able to use them locally, whatever happens. In fact, if you click on any project view button, it may take you to a space that doesn't work.

Flow edit

Flow edit Flow edit

FLUX.1-RealismLora

FLUX.1-RealismLora FLUX.1-RealismLora
View all containers -->
>_ Available for projects

Do you have an AI project?

Let's talk.

maximofn@gmail.com

Machine Learning and AI specialist. I develop solutions with generative AI, intelligent agents and custom models.

Do you want to train your model with these datasets?

short-jokes-dataset

HuggingFace

Dataset with jokes in English

Use: Fine-tuning text generation models for humor

231K rows 2 columns 45 MB
View on HuggingFace →

opus100

HuggingFace

Dataset with translations from English to Spanish

Use: Training English-Spanish translation models

1M rows 2 columns 210 MB
View on HuggingFace →

netflix_titles

HuggingFace

Dataset with Netflix movies and series

Use: Netflix catalog analysis and recommendation systems

8.8K rows 12 columns 3.5 MB
View on HuggingFace →
View more datasets -->