← AUTOMATER NEWSROOM

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.

Diagram of a proactive agent loop: three trigger types feed an agent working toward a goal, which sends check-ins that spend human attention, and human feedback flows back into memory that sharpens the agent.Diagram of a proactive agent loop: three trigger types feed an agent working toward a goal, which sends check-ins that spend human attention, and human feedback flows back into memory that sharpens the agent.
Original illustration of the proactive-agent loop described in LangChain's November 17, 2026 post: triggers wake the agent, check-ins cost human attention, and feedback returns to memory.

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.

The LangChain blog article 'What We've Learned Building Proactive Agents' by Sydney Runkle, showing the article title, author, November 17, 2026 date and the opening section on proactive agents.
LangChain's Agent Architecture blog, the primary source: Sydney Runkle's 'What We've Learned Building Proactive Agents,' published November 17, 2026, which documents the company's internal GTM Agent and Robin agents and the memory and check-in UX lessons from running them. · Original source

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.

Diagram showing three memory signals - seed, feedback and outcomes - writing into an agent memory file that produces sharper check-ins, with salience, expiry and duplication as failure modes below.Diagram showing three memory signals - seed, feedback and outcomes - writing into an agent memory file that produces sharper check-ins, with salience, expiry and duplication as failure modes below.
Original diagram summarizing LangChain's memory model: seed, feedback and outcomes write memory; salience, expiry and duplication are the failure modes a periodic dreaming job must fix.

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.

Three-column diagram of LangChain's check-in UX principles: high signal, built for review, and meeting users where they already work in Slack.Three-column diagram of LangChain's check-in UX principles: high signal, built for review, and meeting users where they already work in Slack.
Original diagram of the three check-in UX principles LangChain credits for GTM Agent and Robin: high signal, built for review, and living in Slack.

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

  1. 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.
  2. 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.
  3. Budget a maintenance pass. Schedule a periodic job that rewrites memory for salience, expiry and duplication - LangChain’s ‘dreaming’ pattern.
  4. Make check-ins cheap to review. One-line headline, details in a thread, an explicit approve or claim button.
  5. Put the agent in the channel people already watch. A separate dashboard nobody opens is where check-ins go to die.
  6. 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.

Sources

  1. What We’ve Learned Building Proactive Agents
  2. From tasks to goals
  3. New context engineering challenges in late 2026