AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Agents Are Going Async

Collected Nov 5, 2026

LangChain has introduced async subagents in Deep Agents, available now for Python and JavaScript and in Managed Deep Agents. The design splits an agent into two roles: an orchestrator that stays available to the user and keeps the conversation's context in order, and subagents that execute long-running work in the background and report back to the orchestrator when they finish. In Managed Deep Agents, marking a subagent async is a matter of setting a single async field to True on its definition.

The motivation is a limitation in the standard ReAct loop. In that pattern the model calls a tool, waits for the result, then decides what to do next, so any long tool call blocks the loop and everything else queues behind it. LangChain frames the alternative with a metaphor: a chief of staff who vanishes whenever handed a big project and returns only when it is done would be fired. A good one keeps work moving while staying reachable. The company argues the wider ecosystem is converging on the same split, pointing to Claude Code running subagents in the background by default, OpenAI's dots handing work to background workers, and DeepSeek Harness building its super agent around a router that talks to users while workers run tasks in parallel.

The mechanics are deliberately similar to familiar concurrency primitives. An async subagent behaves like a task started with asyncio.create_task, or a Promise that is not awaited yet: the call returns immediately, work proceeds independently, and the result arrives later. Two system properties make this work. First, the orchestrator's loop is no longer held by subagents, so the user can reach it whenever its own loop is free. Second, the orchestrator can start subagents as work arrives rather than waiting for an entire batch to return, which means the amount of work an agent can take on scales with the number of background workers rather than the length of a single loop.

The orchestrator manages async subagents through five tools. start_async_task launches a subagent on its own thread and returns right away. check_async_task fetches a task's status and, once it finishes, its result. update_async_task sends new instructions to a running task, cancel_async_task stops one, and list_async_tasks enumerates every task with its status. Reaching the orchestrator and steering a running subagent are treated as separate concerns.

Steering behavior is governed by an update_strategy field on each subagent's definition. The default, interrupt, stops the current run and restarts the subagent with the new instruction, which suits a correction such as switching a chosen database. The alternative, enqueue, holds the follow-up until the current run completes, which suits an addition such as running tests after the work is done. This distinction matters in practice, since an interrupting update discards in-progress work while a queued one preserves it but delays the instruction.

Notifications are handled so the orchestrator always knows what is in flight. Every unfinished task appears in its system prompt, and it can either poll with check_async_task or receive results on its own. The delivery path depends on what the orchestrator is doing. If it is busy, it checks unfinished tasks before each model call and picks up results mid-run. If it is idle, the subagent wakes it with a new run. If it is paused awaiting an approval, that approval is left untouched and the result arrives once the user responds. A subagent that needs approval shows up as waiting, and the user answers on the subagent's own thread without interrupting the orchestrator; in Managed Deep Agents on Slack, the request is posted back to the original thread.

Managed Deep Agents also gives every served agent an async copy of the general-purpose subagent, so it can choose at runtime whether delegated work runs in the foreground or the background. The sample configuration uses define_deep_agent with a model string such as openai:gpt-5.5 and a subagents list containing a researcher with its own description and system prompt. Task notifications are labeled beta, so the API may still change. A repository, async-deep-agents, contains a working supervisor with researcher and coder subagents in Python and TypeScript, and LangChain is directing feedback to GitHub issues and its forum.

LangChain expects the pattern to spread beyond subagents to tools generally, citing OpenAI's recent support for async tool calling, where the model continues working after calling a tool and the application returns the result in a later request. This suggests the blocking tool call, long the default assumption in agent frameworks, is becoming the exception rather than the rule. A likely trade-off is added coordination cost: parallel workers need status tracking, cancellation and conflict handling, and an orchestrator woken repeatedly may spend more of its context on bookkeeping. The interrupt-versus-enqueue choice also puts a design decision in developers' hands that foreground agents never had to make.

Why it matters: Developers building agents on Deep Agents can now keep a user-facing orchestrator responsive while long research, coding or test tasks run in parallel, without rewriting the loop themselves; teams on Managed Deep Agents get it by flipping one field. Product teams gain a more natural interaction model, since users can keep talking and answer approvals on a separate thread instead of waiting for a spinner. Because notifications are still beta, teams that depend on the API should expect changes and pin versions where stability matters, which is an inference from the stated beta status.

Read at LangChain

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Async subagents let an agent stay responsive while background workers run long tasks. How the orchestrator, notifications and approvals work in Deep Agents.