LangChain adds background AI workers so the main agent can keep responding

An AI assistant that accepts a long assignment should not disappear until it finishes. LangChain’s November 5 introduction of async subagents brings that design to Deep Agents: background workers handle delegated tasks while a coordinating agent stays available. There is a boundary, though: users can reach that coordinator when its own processing loop is not busy.

Delegate the work, not the conversation

The change targets a bottleneck in how agents work. A model typically chooses a tool, waits for its answer and then decides what to do next. A slow tool or delegated assignment can hold up that sequence. LangChain’s new arrangement separates the orchestrator—the main agent that talks to the user—from subagents that carry out longer assignments.

Async, short for asynchronous, means the handoff returns immediately rather than waiting for the worker’s answer. The assignment continues independently, and its result arrives later. The orchestrator can start more work as requests arrive instead of waiting for an entire batch to finish. It also keeps the conversation’s context organized while those assignments run elsewhere.

A follow-up can restart work—or wait

LangChain gives the orchestrator five tools to manage the work it delegates, covering the task’s lifecycle rather than just the initial handoff:

• start_async_task starts a subagent on its own thread and returns immediately, leaving the assignment running in the background.
• check_async_task retrieves a task’s status and, after it finishes, its result.
• update_async_task sends new instructions to a running task, with handling determined by the subagent’s configuration.
• cancel_async_task stops a running task without requiring the orchestrator to wait for it to finish.
• list_async_tasks lists every task and its status, giving the orchestrator a view across its delegated assignments.

Reaching the orchestrator and changing a worker’s instructions are separate operations. The default update strategy, interrupt, stops the worker’s current run and restarts it with the new instruction. LangChain gives a correction such as switching to Postgres as an example. The alternative, enqueue, holds the follow-up until the current run finishes—appropriate for an addition such as running tests afterward.

Results return without bypassing approvals

Every unfinished task appears in the orchestrator’s system prompt, the instructions it receives as it works. The orchestrator can check progress itself, or workers can report back. When the orchestrator is busy, it checks unfinished tasks before each model call and can pick up completed results mid-run. When idle, a completed subagent wakes it by starting a new run.

An outstanding approval changes that timing. If the orchestrator is paused for a user’s answer, a worker’s result does not disturb the approval; it arrives after the user responds. A subagent that needs approval is marked waiting, and the user answers on that worker’s own thread without interrupting the orchestrator. In Managed Deep Agents on Slack, the approval request returns to the original thread.

Async subagents are available in Deep Agents for Python and JavaScript, and in Managed Deep Agents. In the managed service, developers enable the behavior with an async field on a subagent definition. Every served agent also gets an async copy of the general-purpose subagent, allowing it to choose foreground or background delegation at runtime. Task notifications remain in beta, and LangChain cautions that their API may change.