LangChain's Proactive-Agent Playbook: Memory and Check-In UX Decide Whether an Agent Earns Autonomy
LangChain's new post reports lessons from running two internal proactive agents, where over 70% of runs start from schedules. Memory design and check-in UX decide whether background agents earn autonomy - here is what to copy.
LangChain runs two proactive agents inside the company. GTM Agent is a sales agent that watches for new leads and replies, sends daily briefs and drafts outbound email. Robin - the engineering agent formerly known as Open SWE - drafts pull requests and reviews every new one. On November 17, 2026, LangChain engineer Sydney Runkle published what operating them has taught the team, and the most revealing number in it is this: more than 70% of runs on LangChain’s Managed Deep Agents platform now come from schedules rather than from an ad hoc human prompt.
That statistic captures where agent products are heading. Personal agents like Muse, Instinct and OpenAI’s dots popularized background agents that work toward larger goals instead of waiting for a prompt; Hone describes its Engines as AI ‘assigned goals rather than tasks.’ When an agent schedules its own wake-ups, the human is no longer the trigger, and human attention becomes the scarce resource the agent spends. LangChain’s conclusion: memory and check-in UX decide whether that spending works.
Three ways a proactive agent wakes up
| Trigger | Who sets it | LangChain’s example |
|---|---|---|
| Real-world events | The environment | Robin starts a review when a pull request opens |
| Developer schedules | The developer | A nightly job that updates the agent’s memory |
| Agent-set schedules | The agent itself | GTM Agent schedules its own daily brief after a user asks for one |
Both internal agents run on all three trigger types. Once wake-ups are routine, the design problem shifts from ‘can the agent do the task’ to ‘should the agent bother you about it’ - and that is a memory question.

Memory turns a tool into a hire
A proactive agent that wakes from a schedule or an event gets no prompt telling it what you want. It can pull fresh context through connectors like your inbox or calendar, but what it has learned about your preferences comes from memory. LangChain sorts memory into three signals, each tied to a different point in time:
| Signal | When | Executive-assistant example |
|---|---|---|
| Seed | Past | Load your sent folder so the assistant starts out knowing your voice and contacts |
| Feedback | Present | Your rewrite or rejection reason teaches it your taste |
| Outcomes | Future | A reply to an email it drafted teaches what works |
Storing memory is the easy part - it is often just a file. Keeping it useful is harder, because the agent acts on whatever it remembers. Three problems recur: salience (deciding what is worth saving), expiry (a launch date that has already passed), and duplication (merging new facts into stored ones instead of saving a second copy that later contradicts the first). LangChain’s mitigation is ‘dreaming,’ a scheduled background job that reads the agent’s recent traces and rewrites memory before the next run.
Memory is also how you measure improvement: track the outcomes a good memory system should move, like how long drafts take to get approved or how often sent emails get replies, and watch the share of check-ins you actually act on. Memory builds trust, too. An agent that remembers your corrections stops repeating them, which earns it more autonomy - the way a coachable new hire gets trusted to book meetings once you stop changing the times they propose.
Check-in UX: proactive without being annoying
Every unrequested message costs the human attention, so a check-in has to earn its interruption. Three principles LangChain landed on:
- High signal. Surface only what is valuable. GTM Agent’s review UI sorts conversations into ones waiting on you, ones that need a draft reply, and ones that need no reply at all.
- Built for review. Review is how your feedback gets back into memory, so every check-in should be fast to review. Robin asks for a pull-request review in Slack with a one-line summary, the size of the change, and a button to claim it; its posts lead with a one- or two-sentence headline and put detail in a thread reply.
- Where you already work. Both agents live in Slack instead of a separate dashboard, and Robin uses the Jev decision model to judge when joining a conversation adds something rather than barging in or waiting to be tagged. Our analogy: the same decision-gate pattern we use for hook-level tool gates in Claude Code; see our Jev gate guide.
The shift underneath: from tasks to goals
The UX pressure follows from the architectural shift LangChain CEO Harrison Chase described the day before: developers are moving from assigning tasks (‘write this email’) to assigning goals (‘maintain a blog,’ ‘reduce my coordination burden’). Under a goal, the agent chooses its own tasks, calls tools the developer did not predict, and needs mechanisms to ask questions, receive feedback and wake itself up - heartbeats, cron jobs, event streams - plus stopping rules, because sometimes doing nothing is the right action. Memory is what lets that feedback compound across runs instead of evaporating.
Chase had already flagged the harder open problems: how to be proactive without being annoying, what a memory system should remember, async coordination between long-running agents, goal tracking, agents gaming badly designed goals, and browser use. Runkle’s post reads as a field report on the first two.
What to do with this this week
- Seed memory before the first run. Load precedent - sent mail, past decisions, docs - so the agent starts with your context instead of discovering it the expensive way.
- Track outcomes, not runs. Pick two or three metrics memory should move, like draft-approval time and the share of check-ins you act on.
- Budget a maintenance pass. Schedule a periodic job that rewrites memory for salience, expiry and duplication - LangChain’s ‘dreaming’ pattern.
- Make check-ins cheap to review. One-line headline, details in a thread, an explicit approve or claim button.
- Put the agent in the channel people already watch. A separate dashboard nobody opens is where check-ins go to die.
- Write stop rules. An agent that always finds something to do will eventually find the wrong thing.
You can build this on Managed Deep Agents, which supports schedules, memory and async subagents, or on the open-source Deep Agents harness, where memory and async subagents work the same way in JavaScript. For a sales-agent case study in the same stack, see our earlier look at how LangChain’s GTM Agent uses templates, business context and a stop rule; for the goal-design side, see LangChain’s Goal Engineering guidance and how Qwen Code ships the same pattern.