Async Subagents Let AI Agents Handle Long Tasks While Staying Responsive
- Cargo
- Machine Learning
- Shipped
- Shipper
- David Rodriguez
- Readers
- 589
Deep Agents’ async subagents run long jobs in the background, keeping the main agent available and able to coordinate parallel work.

Long-running work creates a bottleneck for agents: while one tool call waits for a result, the agent may be unable to respond to a new request or make progress on another task. Async subagents change that arrangement. A main agent can delegate work to background workers, keep talking with the user, and collect results as they arrive.
This pattern is appearing across agent products. Claude Code runs subagents in the background by default, OpenAI’s dots use background workers to make progress on several tasks, and DeepSeek Harness uses a router alongside workers that run tasks in parallel. LangChain is bringing the same approach to Deep Agents through async subagents.
The design separates two roles. An orchestrator remains the agent the user interacts with and keeps the conversation’s context organized. Subagents take on delegated jobs independently and report back when they finish. That lets the system’s capacity grow with the number of background workers, instead of making each task wait for one long sequence of tool calls.
Delegation without waiting
In a typical agent loop, the model calls a tool, waits for its result, then decides what to do next. A slow tool or subagent blocks that loop; other work must wait until the call returns. Async execution changes when the orchestrator waits. Starting a subagent returns control immediately, while the delegated task continues in the background. The idea resembles creating a task with asyncio.create_task or starting a JavaScript Promise without awaiting it right away.

The main agent can manage this work through five tools:
start_async_tasklaunches a subagent on its own thread and returns without waiting for the task to finish.check_async_taskreports a task’s status and returns its result when available.update_async_tasksends new instructions to a running subagent.cancel_async_taskstops a task that is still running.list_async_tasksshows the tasks and their current statuses.
Follow-up instructions can take effect in two ways. With "interrupt", the default, the current run stops and the subagent restarts with the revised instruction. That suits a correction such as switching to Postgres. With "enqueue", the new instruction waits until the current run ends, which fits an extra step such as running tests after the main job.
Results and user approvals
The orchestrator’s system prompt lists unfinished tasks, giving it a record of work in progress. It can check that list by polling with check_async_task, or a subagent can report its result automatically. What happens next depends on the orchestrator’s state: a busy agent checks for completed work before each model call and can incorporate the result during its run; an idle one starts a new run to handle the result. If the orchestrator is paused while awaiting user approval, the subagent’s result waits until the user responds.

Subagents can also need approval to proceed. In that case, the task appears as waiting, and the user responds in the subagent’s own thread, leaving the orchestrator’s conversation available. In Managed Deep Agents on Slack, the request appears in the original thread.
The same asynchronous pattern could apply beyond subagents. OpenAI has added support for async tool calling, which lets a model continue working after calling a tool while the application sends the tool result in a later request. This shifts part of the coordination burden to the application: it must manage pending work and deliver results back into the agent’s process.
Availability and implementation
Async subagents are available in Deep Agents for Python and JavaScript, as well as in Managed Deep Agents. For a managed agent, a subagent can be made asynchronous by setting "async": True in its definition:
from managed_deepagents import define_deep_agent
agent = define_deep_agent(
name="research-assistant",
model="openai:gpt-5.5",
subagents=[
{
"name": "researcher",
"description": "Researches a topic in the background.",
"system_prompt": "Research the topic and report your findings.",
"async": True,
},
],
)Managed Deep Agents also gives each served agent an asynchronous copy of the general-purpose subagent, allowing it to choose at runtime whether delegated work runs in the foreground or background. A working supervisor with researcher and coder subagents in Python and TypeScript is available in the async-deep-agents repository.
Task notifications are in beta, so their API may change. For teams building agents, the practical test is whether background execution improves responsiveness without making task status, updated instructions, and returned results hard to track. Those coordination details will determine how well this pattern handles larger workloads.