On 5 November 2026, LangChain published Agents Are Going Async, describing a Deep Agents setup where a supervising assistant can send work to a subagent and remain available for another conversation. The worker continues on its own thread, so the user can ask something else without waiting for the delegated task to finish.
I can see the appeal. Waiting for research, code or a long comparison to finish before the chat will respond again is a strange constraint to build into an interactive tool.
But when the assistant answers a new question while earlier work remains unresolved, the conversation moves on even though the job hasn't. A responsive assistant and a completed job are two different facts. Chat history alone can't reliably show what's running, what has changed or what still needs attention.
The job needs somewhere to exist
Say I ask an assistant to compare three suppliers. It starts a research worker, then answers a separate question while the comparison continues. When I return to the research later, I need more than the assistant's earlier message saying it started the job. I need to know which job is active, what instructions it has, and whether it has produced anything or become stuck.
LangChain's async-subagent documentation assigns each asynchronous task a task ID associated with its worker thread. A supervising agent can start, check, update, cancel or list tasks, with task metadata maintained separately from ordinary chat history. That matters when conversational history is compacted: the earlier message can leave the working context while the task continues.
A task ID gives the assistant a way to find the work again. It doesn't prove that later instructions reached the worker or that an external action succeeded. I'd want a fresh status check before treating the assistant's account as current.
Changing the plan means choosing what changes
Suppose that supplier-research job is still running when I add: "Use only public information. Don't contact anyone." The assistant might acknowledge the change before the worker has received it, and an action already in progress may be too late to stop.
LangChain documents two ways to update an asynchronous worker. With interrupt, the current run is interrupted and the subagent restarts with the new instruction and its previous conversation. With enqueue, the update waits until the current run finishes. Under the second approach, the worker can keep following its earlier instructions until that happens. Neither approach can undo an email already sent. The provider's announcement and documentation describe these strategies, not a guarantee that external actions are reversible.
An interface that reports only "updated" leaves out a consequential detail. I would want to know whether the running work restarted or the new instruction was queued for later, so I don't mistake an acknowledgment for proof that the restriction already applies.
Cancellation doesn't retrieve the things already sent
LangChain documents cancel_async_task as calling the server's runs.cancel() and marking the task cancelled. That tells us about the cancellation operation and reported task state. By itself, it doesn't prove that every tool stopped before an outside request was accepted, or that a completed external action was reversed.
LangChain's minimal self-hosted server example makes the distinction particularly clear. Its cancellation handler marks a run cancelled in a local database, while noting that the underlying invocation will not be interrupted mid-flight unless actual asyncio cancellation has been connected. That limitation belongs to the example. It is not evidence that the managed product behaves the same way. It shows why a cancellation label and the execution it describes need separate verification.
If my supplier-research worker had started creating a ticket in another service just before cancellation, I would need to establish whether the request was acknowledged, whether execution actually stopped and whether the service accepted the ticket. If the ticket was created, I'd still need to check the ticket service and decide whether to correct or undo it. The worker's cancellation status doesn't settle that.
A background lookup doesn't need an elaborate rollback process. A task that changes another system needs more careful accounting, because stopping the worker and dealing with what it already changed are different actions.
Approval has to belong to a particular task
A background worker may need human approval while the main conversation is discussing something unrelated. LangChain describes tasks entering a waiting state for approval, with the decision routed to the subagent's own thread. That gives the request a task-specific destination.
The approval still needs a clear scope. If one worker wants to write a repository file and another wants to message a supplier, a stray "Yes" in the main conversation shouldn't become permission for whichever task happens to be waiting. I'd want to see the requesting job, the proposed action and target, the limits of the approval and where work will resume. A changed request may need a new decision.
Those are operator requirements I'm drawing from the mechanism, not safeguards proved for every deployment. The documentation establishes task-specific waiting and response routing, but doesn't establish that every installation automatically checks approval scope and freshness in the way I've described.
A notification still needs to find its way home
LangChain also describes completion, failure and approval notifications. An idle orchestrator can be woken for a new run, while an active one can receive a result as it works. The documentation includes beta and version-specific qualifications, so those notifications shouldn't be assumed to work identically or arrive reliably in every setup.
Even when a worker completes, its result may not yet be accounted for. It might have produced a file that the assistant hasn't incorporated into the user's request. The user might not have seen the notification, or a remote change might still need verification. LangChain recommends a fresh check or list operation before reporting current task status rather than relying on an older message.
I've written before about state continuity when long-running work fails. That article deals with recovery after a failure. Here, the assistant is still running normally and unfinished jobs need to remain visible.
Conversation, job, external effect
The conversation carries the user's requests, questions and decisions. It helps coordinate the work but doesn't contain every execution event.
The job has its own identity, current status, instructions, updates, pending approvals and outputs. It may still be running after the conversation moves on.
The external effect is recorded by the system the worker touched, such as a repository, ticket tracker or message service. The worker's status alone doesn't establish what that system accepted or whether a later correction is needed.
The checks should match the risk. Reading public pages for a draft is different from modifying records, messaging someone or initiating a payment. I would keep low-risk tasks light and require clearer approval and verification when outside consequences are harder to reverse. Otherwise the work of tracking agents can become disproportionate to the work they were meant to save.
LangChain's material documents specific mechanisms for nonblocking workers, task identities, updates, cancellations and notifications. It is provider evidence for those mechanisms, not an independent test of performance, reliability or external-effect safety. Limited worker capacity can still queue tasks; asynchronous doesn't mean unlimited parallelism. The reference implementation also notes the extra state-management complexity and that simpler synchronous delegation may suit small, predictable tasks better.
Before I treat delegated work as finished, I'd want to find the right job, check its latest state and verify any consequential change in the system it touched. A chat reply alone can't establish all three.
// End of transmission. Keep the work visible — ZYANE
