---
type: "post"
id: "what-we-ve-learned-building-proactive-agents-8bd10d"
slug: "what-we-ve-learned-building-proactive-agents-8bd10d"
title: "What We’ve Learned Building Proactive Agents"
description: "LangChain’s account of two internal proactive agents turns a broad idea—software that works toward goals between prompts—into practical design guidance."
retrieval_nugget: "LangChain’s account of two internal proactive agents turns a broad idea—software that works toward goals between prompts—into practical design guidance. It describes event and schedule triggers, memory built from context, feedback and outcomes, and review-oriented interfaces. For teams, the central challenge is not just agent autonomy but making each interruption worth a person’s attention."
published_at: "2026-11-17"
updated_at: "2026-11-17"
record_date: "2026-11-17"
date_kind: "published_at"
topics: ["prompts"]
entities: ["LangChain","Managed Deep Agents","Deep Agents","GTM Agent","Robin","Sydney Runkle","Jev"]
related_patterns: ["ai-native-orgs-move-to-review-and-orchestration"]
novelty_label: "new_angle"
what_changed: "LangChain frames long-running agents as proactive problem-solvers that pursue goals in the background and check in when they need clarification or approval."
prior_refs: []
source_url: "https://www.langchain.com/blog/what-weve-learned-building-proactive-agents"
source_urls: ["https://www.langchain.com/blog/what-weve-learned-building-proactive-agents"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:what-we-ve-learned-building-proactive-agents-8bd10d"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/what-we-ve-learned-building-proactive-agents-8bd10d/","markdown":"https://newruntime.com/posts/what-we-ve-learned-building-proactive-agents-8bd10d.md","json":"https://newruntime.com/posts/what-we-ve-learned-building-proactive-agents-8bd10d.json"}
markdown_url: "https://newruntime.com/posts/what-we-ve-learned-building-proactive-agents-8bd10d.md"
---

# What We’ve Learned Building Proactive Agents

## Retrieval answer

LangChain’s account of two internal proactive agents turns a broad idea—software that works toward goals between prompts—into practical design guidance. It describes event and schedule triggers, memory built from context, feedback and outcomes, and review-oriented interfaces. For teams, the central challenge is not just agent autonomy but making each interruption worth a person’s attention.

## Summary
LangChain’s account of two internal proactive agents turns a broad idea—software that works toward goals between prompts—into practical design guidance. It describes event and schedule triggers, memory built from context, feedback and outcomes, and review-oriented interfaces. For teams, the central challenge is not just agent autonomy but making each interruption worth a person’s attention.

## What happened
In a November 17, 2026 article, LangChain engineer Sydney Runkle describes lessons from GTM Agent, a sales agent, and Robin, an engineering agent formerly called Open SWE. GTM Agent watches for new leads and replies, prepares daily briefs and drafts outbound email. Robin drafts pull requests and reviews new ones. LangChain says both agents use real-world events, developer-defined schedules and schedules created by the agent itself. A new pull request can trigger a Robin review; a user can ask GTM Agent for a daily brief, after which the agent schedules it. LangChain says both are built on Managed Deep Agents, where more than 70% of runs now come from schedules rather than ad hoc human prompts.

The article frames memory as a requirement for deciding what merits an interruption. Connectors can retrieve fresh information from sources such as an inbox or calendar, while memory captures what the agent has learned about preferences. LangChain describes three sources of that memory: seed information from the past, such as a sent-mail folder; present feedback, such as a rewritten draft or a rejection with a reason; and future outcomes, such as whether a drafted email receives a reply. The company says storing memory may be as simple as a file, but keeping it useful requires handling salience, expiry and duplication. It describes “dreaming” as a scheduled background job that reviews recent traces and updates memory before a later run.

LangChain recommends evaluating memory against outcomes rather than treating storage itself as success. For an email assistant, examples include how long drafts take to be approved and how often sent messages receive replies. The share of agent check-ins that a person acts on is another suggested measure. The article links better memory to greater autonomy: when an agent incorporates corrections and stops repeating mistakes, a user may be more willing to trust it with work without direct supervision.

The second design area is the human-facing experience. LangChain says proactive agents should surface high-signal items, make each check-in quick to review, and live where people already work. GTM Agent sorts conversations into those awaiting the user, those needing a draft and those needing no reply. Robin uses a decision model called Jev to decide when to join Slack conversations. Its pull-request messages lead with a short summary, the change’s size and a way to claim review; more detail can follow in a thread. LangChain says its agents operate in Slack, where users can message or tag them and scheduled work can return to the same conversation.

The company says builders can use Managed Deep Agents, which supports schedules, memory and asynchronous subagents, or start with memory and asynchronous subagents in the open-source Deep Agents harness, including its JavaScript implementation. The article does not give pricing or quantify how these agents compare with a non-proactive baseline.

## What the archive adds
New Runtime’s earlier coverage on November 13, 2026, described Anthropic’s guide to always-on agents, including context management across sessions and proactive action: [Building always-on agents: Claude by Anthropic](https://newruntime.com/posts/building-always-on-agents-claude-by-anthropic-b69b9f/). LangChain adds a separate company account with specific memory inputs, evaluation measures and Slack interaction choices; this is a new fact on a known topic, not the same event.

## Trend signal
This supports the pattern that AI-native organizations move toward review and orchestration: [AI-native organizations move toward review and orchestration](https://newruntime.com/patterns/ai-native-orgs-move-to-review-and-orchestration/). LangChain’s examples make human attention and review part of agent design, with short check-ins, feedback loops and measures such as approval time and whether users act on a notification. The account does not establish that these measures improve across organizations, but it gives a concrete operating example of the pattern.

## Why now
LangChain presents proactive agents as a shift from responding to individual prompts toward work that unfolds across events and schedules, sometimes over days or weeks. Its reported share of scheduled runs suggests that this mode is already used in its own Managed Deep Agents deployment. The timing matters for builders because a system that acts between prompts creates a recurring product question: how to earn attention without turning every background event into an interruption.

## Connections to other events
New Runtime’s earlier coverage on November 14, 2026, reported that LangChain Academy announced a course on building and deploying managed deep agents with LangSmith: [LangChain Academy New Course: Building and Deploying Managed Agents](https://newruntime.com/posts/langchain-academy-new-course-building-and-deploying-managed-bfa1d7/). This article complements that training announcement with LangChain’s account of the design choices behind its own proactive agents, rather than announcing a new course or product release.

## Why it matters
A proactive agent can create work for its user even when its underlying task succeeds: someone still has to notice the message, decide whether it matters and review the proposed action. LangChain’s guidance treats that attention cost as a design constraint. For teams, this changes what to evaluate. Counting runs or generated drafts says little about whether an agent is useful; approval time, useful replies and the share of check-ins that prompt action are closer to the human outcome.

The described memory loop also suggests a way to make autonomy earned rather than assumed. Seed an agent with relevant history, capture corrections, and look at what happens after it acts. Then use that information to update its memory and decide where it can safely take on more responsibility. The article is a vendor’s account of internal systems, not an independently measured comparison, but its mechanisms give teams concrete design questions to test in their own workflows.

## Limits and uncertainty
The article reports that more than 70% of Managed Deep Agents runs are scheduled, but it does not specify the measurement period or the number of runs behind that share. LangChain does not provide numerical results for approval time, reply rates, the fraction of useful check-ins or changes in user trust. The examples describe internal agents and design choices; they do not establish that the same trigger, memory or review setup will work for other teams. The claims are not independently verified here, and the article does not quantify costs or compare the approach with alternatives.

## Skill to build now
Pick one recurring workflow where a person already reviews drafts or alerts. Define three memory inputs before the first run: relevant precedent, explicit user corrections and outcomes after action. Add one scheduled review of recent traces to merge duplicates and retire stale facts. Then make the check-in easy to judge in the team’s existing workspace, with a short headline and details available on demand. Track approval time and the share of check-ins that lead to action before expanding the agent’s autonomy.

## Reader takeaway
Proactive agents need to manage human attention as carefully as they manage task context. LangChain’s practical pattern is to connect memory to feedback and outcomes, keep check-ins selective and reviewable, and judge usefulness by what people do with them—not by how often the agent runs.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Prompts](https://newruntime.com/topics/prompts.md): Explore the prompts topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
