Source: Sydney Runkle, What We've Learned Building Proactive Agents (LangChain blog, 2026-11-17), shared by LangChain on LinkedIn. Lessons from two internal agents: GTM Agent (sales: watches leads and replies, sends daily briefs, drafts outbound email) and Robin (engineering, formerly Open SWE: drafts pull requests and reviews every new one). Both run on LangChain's Managed Deep Agents, where the post reports that more than 70% of runs now start from a schedule rather than a human prompt. The post is vendor-written and ends with a product pitch; the design lessons stand on their own.
The shape of a proactive agent
A proactive agent works toward a goal in the background and decides for itself when to come to a person. It wakes on three kinds of trigger:
Real-world events: a new email, a newly opened pull request.
Developer schedules: a nightly memory update, a weekly sweep for stale pull requests.
Agent-set schedules: a follow-up the agent books for tomorrow, or a daily brief a user asked for.
When it wakes, there is no prompt saying what the person wants. Connectors bring fresh context (inbox, calendar, repo), but preferences and judgment come only from memory. Every check-in costs the person attention, so the core design problem is being proactive without being annoying. Human attention, not model context, becomes the scarce resource.
Memory: three signals, three maintenance problems
The post sorts memory inputs by time:
Seed (past): precedent loaded before the first run, for example an assistant reading the sent folder to learn tone and contacts.
Feedback (present): how the person responds to proposals; a rewritten or rejected draft with a reason teaches voice and taste.
Outcomes (future): what happened after the agent acted; a drafted email that got a reply is evidence of what works.
Storing memory is easy (often just a file). Keeping it useful is hard because the agent acts on whatever it remembers:
Salience: what is worth saving, and how much it matters.
Expiry: recognizing stale facts, such as a launch date that has passed.
Duplication: merging into existing memory instead of writing a second copy that later contradicts the first.
A common fix is "dreaming": a scheduled background job that reads recent traces and rewrites memory before the next run. To tell whether memory helps, track outcomes it should improve, such as time to approve a draft, reply rate, and, for any proactive agent, the share of its check-ins the person actually acts on. Memory is also what earns autonomy: once the person stops correcting a behavior (say, proposed meeting times), the agent can be trusted to do it alone.
UX: high signal, built for review, where people already work
High signal. Not every event warrants action. GTM Agent's review view sorts conversations into waiting on you, needs a draft, and needs no reply. For Slack, Robin uses a separate decision model to judge when joining a thread adds something, instead of interjecting or waiting to be tagged.
Built for review. Every check-in should be quick to review, because review is the channel by which feedback reaches memory. Taste and judgment are rarely written down, so this loop carries the most valuable context. When reviewing a backlog of drafts in Slack was too slow, the team built a custom review UI.
Where people already work. Agents live in Slack: DM or tag them, and scheduled output posts back into the thread where it was requested. Messages lead with a one- or two-sentence headline and put detail in a thread reply; Robin's review requests carry a one-line summary, change size and a claim button.
The framing: context engineering for the model still matters, but proactive agents add context engineering for humans, giving the person the right context, in the right format, at the right time.
Tradeoffs
Silence vs. misses. Tightening salience lowers interruptions but raises the chance of not surfacing something that mattered; the cost is asymmetric and rarely measured.
Self-scheduling vs. control. Agent-set schedules make follow-through easy but create recurring work nobody explicitly approved, and they accumulate.
Rewriting memory vs. auditability. A dreaming job that merges and expires entries keeps memory clean but can silently drop or distort a correction the person gave.
Chat surface vs. structured review. Slack is where people are, but it is a poor place to review many items; the team needed a dedicated UI for bulk drafts.
Failure modes to plan for
Notification fatigue: the person mutes the agent, feedback stops, and memory stops improving.
Stale or contradictory memory acted on confidently (expired dates, duplicated preferences).
Feedback captured without a reason, so the agent learns the wrong rule from a rejection.
Autonomy granted on a narrow track record and then used in a case the person never reviewed.
Orphaned self-scheduled jobs that keep running after the goal or the requester has gone.
Outcome signals that reward the wrong thing (reply rate rewarding pushy email).
Review checklist
Is every trigger type (event, developer schedule, agent schedule) listed, owned and visible, including how to cancel agent-created schedules?
What is the agent's rule for when to interrupt, and is the acted-on rate of check-ins tracked?
Where does memory live, who can read and edit it, and how are salience, expiry and duplicates handled?
If a dreaming job rewrites memory, is there a diff or history so a dropped correction can be found?
Does each check-in lead with a one-line headline and a single clear action?
Is rejection feedback captured with a reason?
What evidence moves a behavior from approval-required to autonomous, and can it be revoked?
Related entries
R084 Building always-on agents: five primitives for agents that sleep, wake and act.
R050 Taking human waits out of the session: end the turn and resume on the reply.
R035 Long-horizon agents and durable execution.
R083 15 building blocks of agent memory.