Agents Have Been Stuck in a Loop for Too Long, and LangChain Is Starting to Split Foreground and Background

Agents have been stuck in a single ReAct loop for too long. In the past, an agent ran in a single loop: the model called a tool, waited for the result, and then decided the next step. Once a tool or subtask ran for several minutes, the entire loop was blocked, and new messages you sent could only queue behind it.

On November 5, LangChain published 'Agents Are Going Async' by S. Runkle and T. Bengre. The change described in the article is to split the agent into foreground and background layers. An orchestrator stays in the foreground talking with you, while long tasks are handed off to background subagents. Claude Code runs subagents in the background by default, OpenAI's dots hands work off to background workers, and DeepSeek Harness also uses a similar routing-plus-background-worker structure.

The key difference is in how they are invoked. An old-style subagent is like an await line: if it does not return, it blocks. An async subagent is like asyncio.create_task, or a Promise without await: the call returns immediately, the work runs on an independent thread, and the result comes back later. The amount of work an agent can take on at once grows with the number of background workers, and it is no longer limited by the length of a single loop.

The orchestrator manages background tasks with five tools: start_async_task starts one, check_async_task checks status and results, update_async_task sends new instructions, cancel_async_task stops one, and list_async_tasks lists all of them.

There are two strategies for changing a task while it is running. The default, interrupt, interrupts the current run and restarts it with new instructions, which suits corrections like 'switch to Postgres.' enqueue accumulates new instructions and executes them after the current round finishes, which suits additions like 'run the tests after you're done.'

How results come back also depends on the situation. If the orchestrator is busy, it scans unfinished tasks before each model call and picks up results along the way. If it is idle, the subagent wakes up a new run. If it is stuck waiting for your approval, the approval stays pending; the result arrives only after you answer. Subtasks that need approval wait in their own thread and do not interrupt the foreground; in Slack's Managed Deep Agents, the request is sent back to the original thread.

How to use it is really just one field. In Managed Deep Agents, add async: True to a subagent:

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,
        },
    ],
)

Both the Python and JavaScript versions of Deep Agents already support this. Each managed agent also automatically gets an async copy of a general-purpose subagent, and at runtime it decides whether to put work in the foreground or background. Notifications are still in beta, and the API may change.

One commenter asked about a detail: when appending with enqueue, if a subagent has already written intermediate artifacts to some temporary path in the previous round, will the instruction appended by the orchestrator via update_async_task read stale results? Or does Deep Agents maintain its own state snapshot for each subagent, so appended instructions are automatically bound to the new snapshot? The original article does not answer this. Task notifications are still in beta, so this question can wait for official follow-up.

One commenter summarized the foreground experience more directly: while a background task is running, the foreground only receives a status—running, completed, or stopped at some error. Logs stay in the subtask's own record for now. If the direction is wrong, stop it and restart; if you are just adding tests, queue them after this round finishes.

Another commenter said that once a tool runs for several minutes, the entire ReAct loop is blocked, and new messages can only queue behind it. After splitting into a foreground that chats with the user and a background for long tasks, you can interject midstream and still pick up the thread without waiting idly. Someone else mentioned that this is very similar to DeepSeek's super agent approach.

OpenAI recently also added async tool calling: after the model calls a tool, it keeps working, and the application sends the result back in a subsequent request. This LangChain article describes subagent asynchrony more concretely—five tools, two update strategies, and three notification paths—basically laying out the skeleton for foreground-background collaboration.

Original article link: https://langchain.com/blog/agents-are-going-async
Tweet link: https://x.com/yibie/status/2118575832767836166