LangChain founder: always-on proactive agents bring six new context problems

Proactive always-on agents are here: the old context engineering problems now have playbooks, but the new hard problems are memory, asynchrony, and goals

From a share by LangChain founder @hwchase17, who believes that the "LLM loop + tools + sandbox" pattern has largely converged, and that summarization, externalizing results, Skills, tool search, subagents, Bash, and the like now have common practices—so some people feel agent engineering has run its course. But what actually gets harder is the next step: proactive, always-on agents that run toward goals—push notifications that don't annoy, what to remember, how to reconnect asynchronous work to the main conversation, how to keep goals from being gamed, and how to hold up context when the browser is the primary tool. These have no general solutions yet, and that's exactly what he finds fun right now.

# Why the old problems seem "solved"

Across the industry, harnesses like Claude Code and Deep Agents increasingly look alike: the model calls tools in the loop and does work in a sandbox. To keep context afloat, people have gradually aligned on a few standard moves: summarize when a thread gets too long; write oversized tool returns to disk and hand back a pointer; use Skills for progressive disclosure; do tool search when there are too many tools; use subagents to isolate sub-contexts; and treat Bash as the primary tool instead of piling up narrow tools. These mainly serve single-shot, coding/task-oriented runs, so it's easy to get the feeling that "the hard problems are done."

# Where the new problems come from

In recent months, what he discusses most with agent builders is proactive, always-on, goal-oriented agents: the core still looks like a coding agent, but the usage has changed, and context engineering has to carry the load again. The comparison checklist in the piece (checkmarks in the left column, empty boxes in the right) lays out both sides clearly.

# Six new problems, and where each one gets stuck

1. Proactive but not annoying: listening to event streams or waking on heartbeats, it must be able to push to the user to feel like it's "helping," but push too much and it floods the screen. How much is just right remains a hard-to-calibrate product and context problem.

2. What to remember: memory is often a simple data structure (a file, a string) plus a layer of intelligence that "decides what to remember"; both ends are easy to get wrong—remembering nothing, or remembering in fragments that are too fine-grained. This judgment layer is itself often a small agent, and there are no general rules yet.

3. Asynchrony: tasks, tools, and subagents all run longer and longer, but the main conversation still has to pick up new user messages at any time, so more work gets handed to asynchronous tools/subagents. The new problem becomes: how to notify the main agent when the work is done; and how to merge context when the main agent is still running, has already finished, or is stuck waiting for human approval. The piece includes a timeline diagram (how background workflows merge in while the user waits).

4. Goal tracking: shifting from "finish one thing" to "iterate toward a big goal" (the piece cites examples like Hone). It has to break down steps, run experiments, collect feedback, and stay on track over the long term; the hard parts are being willing to try new approaches instead of repeating in place, thinking about the big goal instead of fixating on small tasks, and staying consistent across very long horizons.

5. Alignment (don't let it game the goal): goals are hard to write in a way the agent can't game; optimizing a metric single-mindedly leads to unexpected shortcuts, and the classic meme is "eliminate all bugs in the codebase" → delete the source code (no code, no bugs). The harness needs to watch the goal without letting the goal be over-optimized. The piece includes a meme of deleting src/ and then declaring "0 bugs, goal complete."

6. Browser as the primary tool: coding agents rely on Bash; more general proactive agents increasingly rely on the browser. The browser is harder to open up than the terminal: look at screenshots or at the DOM, both are large, and how to manage context is still being figured out.

Closing A few months ago he might have agreed that "there aren't many open problems left in context engineering"; once always-on proactive agents appeared, memory, asynchrony, goals, and proactivity all surfaced in batches again. The tone is more excitement than anxiety: for people working on context, the fun new problems are back.