{"article":{"slug":"agents-are-going-async","title":"Agents Are Going Async","subtitle":null,"summary":"LangChain argues agent systems are shifting to async subagents so a main agent can stay responsive to users while background work continues—covering the design, APIs, and product implications in Deep Agents.","content_type":"blog_post","language":"en","canonical_url":"https://www.langchain.com/blog/agents-are-going-async","author":{"name":"Sydney Runkle, Thushanth Bengre","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"LangChain","url":"https://www.langchain.com/","listing_slug":"langchain","listing":{"slug":"langchain","name":"LangChain","listing_type":"company","url":"https://listedstartups.com/companies/langchain"}},"topics":[{"name":"AI Agents","slug":"ai-agents","url":"https://listedarticles.com/topics/ai-agents"},{"name":"LLMs","slug":"llms","url":"https://listedarticles.com/topics/llms"},{"name":"Software Engineering","slug":"software-engineering","url":"https://listedarticles.com/topics/software-engineering"}],"about_listings":[],"cover_image_url":"https://cdn.prod.website-files.com/65c81e88c254bb0f97633a71/6aecdf22f0b192d15c132b25_6aecdf0372d986b4c1a140a7_async-subagents-cover-webflow.png","license":"all-rights-reserved","word_count":929,"reading_minutes":4,"published_at":"2026-11-05T00:00:00.000Z","added_at":"2026-11-07T02:18:07.246Z","updated_at":"2026-11-07T02:18:07.246Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/agents-are-going-async","markdown_url":"https://listedarticles.com/articles/agents-are-going-async.md","example":false,"citation":"Sydney Runkle, Thushanth Bengre, LangChain. \"Agents Are Going Async.\" 5 Nov 2026. https://www.langchain.com/blog/agents-are-going-async (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://www.langchain.com/blog/agents-are-going-async"},"body_markdown":"## Key Takeaways\n\n- As agents take on bigger goals, they need to stay responsive to the user while making progress on many long tasks at once.\n- Async subagents split an agent into an orchestrator that stays available to the user and subagents that run tasks in the background and report back to the orchestrator upon completion.\n- Background work is becoming the norm for agent infrastructure, from coding agents like Claude Code to personal agents like OpenAI's dots.\n\nImagine a chief of staff who disappears every time you hand them a big project and only comes back once it's done. You'd probably fire them immediately. A good chief of staff keeps projects moving in the background while staying reachable and keeping you updated along the way. As we ask agents to work toward bigger goals, they need the same two properties. An agent has to be responsive, acting on a new instruction right away with the context of everything before it, and productive, making progress on many large tasks at once.\n\nThe architecture we've used to build agents for a while *can't* meet both requirements. In a standard ReAct loop, each long tool call blocks the loop and every other task queues behind it. Instead, we're seeing the ecosystem converge on a split between one agent that stays with the user and background workers that do the long work. [Claude Code](https://code.claude.com/docs/en/sub-agents) runs subagents in the background by default, OpenAI's [dots](https://learn.chatgpt.com/docs/dots) hand work to background workers to make progress on several things at once, and [DeepSeek Harness](https://x.com/DeepSeekHarness/status/2116857257245987236) built its super agent around a router that talks to people and background workers that run tasks in parallel.\n\nWe’re bringing this pattern to [Deep Agents](https://www.langchain.com/deep-agents) with [async subagents](https://docs.langchain.com/oss/python/deepagents/async-subagents). An orchestrator stays available to the user and keeps the conversation's context organized, while async subagents run as background workers and report back when they finish. The amount of work the agent can take on then grows with the number of background workers instead of the length of one loop.\n\n## How async subagents work\n\nAn agent runs in a loop. The model calls a tool, waits for the result, and decides what to do next. Historically, tools and subagents blocked that loop until they returned, like code that awaits each slow call in turn. An async subagent works like a task started with `asyncio.create_task` or a `Promise` you don't await yet. The call returns right away, the work runs independently in the background, and the result comes back later.\n\nAsync work depends on two properties of the system:\n\n- **The user can reach the orchestrator.** The orchestrator is the agent the user interacts directly with. Subagents no longer hold its loop, so the user can reach it whenever its own loop isn't busy, instead of waiting for every subagent to finish.\n- **Tasks run in parallel without blocking.** The orchestrator starts subagents as work comes in, instead of waiting for a whole batch to return.\n\nThe orchestrator manages async subagents with five tools:\n\n- `start_async_task` starts a subagent on its own thread and returns right away.\n- `check_async_task` gets a task's status and, once it finishes, its result.\n- `update_async_task` sends a running task new instructions.\n- `cancel_async_task` stops a running task.\n- `list_async_tasks` lists every task and its status.\n\nSteering a running subagent is separate from reaching the orchestrator. When the orchestrator sends a follow-up with `update_async_task`, the `update_strategy` field on that subagent's definition decides what happens:\n\n- `\"interrupt\"` (the default) stops the current run and restarts the subagent with the new instruction. Use it for a correction like \"use Postgres instead.\"\n- `\"enqueue\"` holds the follow-up until the current run finishes. Use it for an addition like \"run the tests when you're done.\"\n\n## How notifications work\n\nEvery unfinished task is listed in the orchestrator's system prompt, so it always knows what's in flight. It can poll with `check_async_task` or tasks can [report back on their own](https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents#get-notified-when-a-subagent-finishes):\n\n- If the orchestrator is **busy** , it checks its unfinished tasks before each model call and picks up the result mid-run.\n- If it's **idle** , the subagent wakes it with a new run.\n- If it's **paused** on an approval, the approval is left alone, and the result arrives once the user answers.\n\nA 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 [posts back to the original thread](https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents#answer-approvals-in-channels).\n\nWe expect this pattern to generalize beyond subagents to tools across the board. OpenAI recently added support for [async tool calling](https://developers.openai.com/api/docs/guides/async-tool-calling), where the model keeps working after it calls a tool and your application sends the result back in a later request.\n\n## Use async subagents\n\nAsync subagents are available in Deep Agents for [Python](https://docs.langchain.com/oss/python/deepagents/async-subagents) and [JavaScript](https://docs.langchain.com/oss/javascript/deepagents/async-subagents), and in [Managed Deep Agents](https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents), where making a subagent async takes one field:\n\n```\nfrom managed_deepagents import define_deep_agent\nagent = define_deep_agent(\n    name=\"research-assistant\",\n    model=\"openai:gpt-5.5\",\n    subagents=[\n        {\n            \"name\": \"researcher\",\n            \"description\": \"Researches a topic in the background.\",\n            \"system_prompt\": \"Research the topic and report your findings.\",\n            \"async\": True,\n        },\n    ],\n)\n```\nIn Managed Deep Agents, every served agent also gets an async copy of the `general-purpose` subagent, so it can decide at runtime whether to run delegated work in the foreground or the background.\n\nTask notifications are in beta, so the API may still change. The [async-deep-agents](https://github.com/langchain-ai/async-deep-agents) repo has a working supervisor with researcher and coder subagents in Python and TypeScript.\n\nGive async subagents a try, and let us know what you think in [GitHub issues](https://github.com/langchain-ai/deepagents/issues) or on the [forum](https://forum.langchain.com/).","body_html":"<h2 id=\"key-takeaways\">Key Takeaways</h2>\n<ul><li>As agents take on bigger goals, they need to stay responsive to the user while making progress on many long tasks at once.</li><li>Async subagents split an agent into an orchestrator that stays available to the user and subagents that run tasks in the background and report back to the orchestrator upon completion.</li><li>Background work is becoming the norm for agent infrastructure, from coding agents like Claude Code to personal agents like OpenAI&#39;s dots.</li></ul>\n<p>Imagine a chief of staff who disappears every time you hand them a big project and only comes back once it&#39;s done. You&#39;d probably fire them immediately. A good chief of staff keeps projects moving in the background while staying reachable and keeping you updated along the way. As we ask agents to work toward bigger goals, they need the same two properties. An agent has to be responsive, acting on a new instruction right away with the context of everything before it, and productive, making progress on many large tasks at once.</p>\n<p>The architecture we&#39;ve used to build agents for a while <em>can&#39;t</em> meet both requirements. In a standard ReAct loop, each long tool call blocks the loop and every other task queues behind it. Instead, we&#39;re seeing the ecosystem converge on a split between one agent that stays with the user and background workers that do the long work. <a href=\"https://code.claude.com/docs/en/sub-agents\" rel=\"nofollow ugc noopener\">Claude Code</a> runs subagents in the background by default, OpenAI&#39;s <a href=\"https://learn.chatgpt.com/docs/dots\" rel=\"nofollow ugc noopener\">dots</a> hand work to background workers to make progress on several things at once, and <a href=\"https://x.com/DeepSeekHarness/status/2116857257245987236\" rel=\"nofollow ugc noopener\">DeepSeek Harness</a> built its super agent around a router that talks to people and background workers that run tasks in parallel.</p>\n<p>We’re bringing this pattern to <a href=\"https://www.langchain.com/deep-agents\" rel=\"nofollow ugc noopener\">Deep Agents</a> with <a href=\"https://docs.langchain.com/oss/python/deepagents/async-subagents\" rel=\"nofollow ugc noopener\">async subagents</a>. An orchestrator stays available to the user and keeps the conversation&#39;s context organized, while async subagents run as background workers and report back when they finish. The amount of work the agent can take on then grows with the number of background workers instead of the length of one loop.</p>\n<h2 id=\"how-async-subagents-work\">How async subagents work</h2>\n<p>An agent runs in a loop. The model calls a tool, waits for the result, and decides what to do next. Historically, tools and subagents blocked that loop until they returned, like code that awaits each slow call in turn. An async subagent works like a task started with <code>asyncio.create_task</code> or a <code>Promise</code> you don&#39;t await yet. The call returns right away, the work runs independently in the background, and the result comes back later.</p>\n<p>Async work depends on two properties of the system:</p>\n<ul><li><strong>The user can reach the orchestrator.</strong> The orchestrator is the agent the user interacts directly with. Subagents no longer hold its loop, so the user can reach it whenever its own loop isn&#39;t busy, instead of waiting for every subagent to finish.</li><li><strong>Tasks run in parallel without blocking.</strong> The orchestrator starts subagents as work comes in, instead of waiting for a whole batch to return.</li></ul>\n<p>The orchestrator manages async subagents with five tools:</p>\n<ul><li><code>start_async_task</code> starts a subagent on its own thread and returns right away.</li><li><code>check_async_task</code> gets a task&#39;s status and, once it finishes, its result.</li><li><code>update_async_task</code> sends a running task new instructions.</li><li><code>cancel_async_task</code> stops a running task.</li><li><code>list_async_tasks</code> lists every task and its status.</li></ul>\n<p>Steering a running subagent is separate from reaching the orchestrator. When the orchestrator sends a follow-up with <code>update_async_task</code>, the <code>update_strategy</code> field on that subagent&#39;s definition decides what happens:</p>\n<ul><li><code>&quot;interrupt&quot;</code> (the default) stops the current run and restarts the subagent with the new instruction. Use it for a correction like &quot;use Postgres instead.&quot;</li><li><code>&quot;enqueue&quot;</code> holds the follow-up until the current run finishes. Use it for an addition like &quot;run the tests when you&#39;re done.&quot;</li></ul>\n<h2 id=\"how-notifications-work\">How notifications work</h2>\n<p>Every unfinished task is listed in the orchestrator&#39;s system prompt, so it always knows what&#39;s in flight. It can poll with <code>check_async_task</code> or tasks can <a href=\"https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents#get-notified-when-a-subagent-finishes\" rel=\"nofollow ugc noopener\">report back on their own</a>:</p>\n<ul><li>If the orchestrator is <strong>busy</strong> , it checks its unfinished tasks before each model call and picks up the result mid-run.</li><li>If it&#39;s <strong>idle</strong> , the subagent wakes it with a new run.</li><li>If it&#39;s <strong>paused</strong> on an approval, the approval is left alone, and the result arrives once the user answers.</li></ul>\n<p>A subagent that needs approval shows up as <code>waiting</code>, and the user answers on the subagent&#39;s own thread without interrupting the orchestrator. In Managed Deep Agents on Slack, the request <a href=\"https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents#answer-approvals-in-channels\" rel=\"nofollow ugc noopener\">posts back to the original thread</a>.</p>\n<p>We expect this pattern to generalize beyond subagents to tools across the board. OpenAI recently added support for <a href=\"https://developers.openai.com/api/docs/guides/async-tool-calling\" rel=\"nofollow ugc noopener\">async tool calling</a>, where the model keeps working after it calls a tool and your application sends the result back in a later request.</p>\n<h2 id=\"use-async-subagents\">Use async subagents</h2>\n<p>Async subagents are available in Deep Agents for <a href=\"https://docs.langchain.com/oss/python/deepagents/async-subagents\" rel=\"nofollow ugc noopener\">Python</a> and <a href=\"https://docs.langchain.com/oss/javascript/deepagents/async-subagents\" rel=\"nofollow ugc noopener\">JavaScript</a>, and in <a href=\"https://docs.langchain.com/langsmith/python/managed-deep-agents-subagents\" rel=\"nofollow ugc noopener\">Managed Deep Agents</a>, where making a subagent async takes one field:</p>\n<pre><code>from managed_deepagents import define_deep_agent\nagent = define_deep_agent(\n    name=&quot;research-assistant&quot;,\n    model=&quot;openai:gpt-5.5&quot;,\n    subagents=[\n        {\n            &quot;name&quot;: &quot;researcher&quot;,\n            &quot;description&quot;: &quot;Researches a topic in the background.&quot;,\n            &quot;system_prompt&quot;: &quot;Research the topic and report your findings.&quot;,\n            &quot;async&quot;: True,\n        },\n    ],\n)</code></pre>\n<p>In Managed Deep Agents, every served agent also gets an async copy of the <code>general-purpose</code> subagent, so it can decide at runtime whether to run delegated work in the foreground or the background.</p>\n<p>Task notifications are in beta, so the API may still change. The <a href=\"https://github.com/langchain-ai/async-deep-agents\" rel=\"nofollow ugc noopener\">async-deep-agents</a> repo has a working supervisor with researcher and coder subagents in Python and TypeScript.</p>\n<p>Give async subagents a try, and let us know what you think in <a href=\"https://github.com/langchain-ai/deepagents/issues\" rel=\"nofollow ugc noopener\">GitHub issues</a> or on the <a href=\"https://forum.langchain.com/\" rel=\"nofollow ugc noopener\">forum</a>.</p>","headings":[{"level":2,"text":"Key Takeaways","id":"key-takeaways"},{"level":2,"text":"How async subagents work","id":"how-async-subagents-work"},{"level":2,"text":"How notifications work","id":"how-notifications-work"},{"level":2,"text":"Use async subagents","id":"use-async-subagents"}]}}