Managed Deep Agents v0.10: Browser Handoff, Async Subagents, and the Breaking Changes in LangChain's Release Post

LangChain released Managed Deep Agents v0.10 on October 29, in public beta. Per the release post, it adds two main things: a browser your agent can drive on sites with no API, with a handoff so a person types the password instead of the model, and async subagents that run in the background while the main agent keeps talking to you. It also removes some things, which is the part to read before you upgrade.

I read the full release post. I did not read the linked docs (browser use, runtime, Slack channel), the source or the package, and I did not run anything. Everything below is what LangChain's post says.

Browser use

You declare a browser at the project root with define_browser, and the post's example sets scope="thread" and idle_ttl_seconds=600. The post says the browser runs in its own LangSmith sandbox and adds four tools to the agent automatically:

• browser_snapshot: reads the page's accessibility tree and assigns element IDs.
• browser_run: navigates and interacts, through JavaScript or batches of actions against snapshot IDs.
• browser_screenshot: captures the page, optionally saving the image to the sandbox.
• browser_handoff: gives a person control of the window.

Scopes. By default each conversation gets its own browser, reused across turns, with no cookies or logins from other threads. With scope="user", each signed-in person gets one browser whose logins carry across their conversations, so the agent asks them to sign in to a site once.

Handoff. The agent calls browser_handoff(reason) and explains why it needs you. In Slack and Studio, the post says a link opens the remote browser with a Hand back button. Custom clients render the handoff artifact themselves. After you sign in and hand back, the agent checks whether the login worked and continues. The call returns immediately so the agent can do other work, and handoff links expire after 15 minutes. LangChain's stated benefit: the password does not end up in the model's messages or traces.

That claim is about the model's context. It does not tell you where the session cookies live or who can read the sandbox. With scope="user", logins persist across conversations, which makes that question worth asking.

Async subagents

Before v0.10, the post says subagents ran inline and the agent waited for the answer. Now you add "async": True to a subagent definition, and the agent starts it on its own thread and keeps talking to the user. The orchestrator starts, checks on, updates and cancels these tasks with a set of async task tools. Every served agent also gets a background copy of a general-purpose subagent, so it can choose at runtime between foreground and background.

The post says async subagents notify the agent themselves, so there is no polling loop. What happens when one finishes depends on what the agent is doing:

• Busy: it checks unfinished tasks before each model call, so the result arrives mid-run.
• Idle: the subagent wakes it with a new run.
• Paused on an approval: the approval is left alone, and the result arrives once the user answers.

An async subagent shares the agent's sandbox, so it sees files the agent already wrote. Its run appears under the agent's run in LangSmith, and in Slack its approvals post back to the original thread.

Other changes in v0.10

• runtime.thread: every thread records where it started, such as a Slack thread, and who is on it. The post says this is how a Studio resume, a scheduled run and an async subagent's wake-up run all reply in the original Slack thread.
• Stopping runs: Slack threads get a native Stop button that cancels the thread's runs, and Studio can cancel runs on Slack threads.
• Slack channel handlers (experimental): onEvent decides what each Slack event starts, status sets what Slack shows while a run works, and reply: "none" leaves replying to the agent.
• Bring your own Slack app: mda deploy asks which app a new Slack channel should use.
• resolveUser: maps a verified sender in a channel like Slack to a user in your own system, so tools can look up that person's account and permissions. You write it as a function or point it at an endpoint LangChain calls.

Breaking changes

The post lists these directly:

• connectors.mcp() and the connectors/ layout are removed. MCP servers must be declared in tools/mcp.ts or tools/mcp.py.
• The sandbox scope option is removed.
• For LANGSMITH_* variables, shell environment variables now win over a project .env.

The third one can change behavior without any error. If a shell variable and your .env file disagree, the shell value is now used.

Getting started, as shown

The post shows uvx --from managed-deepagents mda init my-agent, then uv run mda deploy. It says v0.10 is in public beta.

What the post does not say

• Pricing or limits for the browser sandbox or for async subagents. I did not see any in the post.
• How many async subagents can run at once.
• What happens to a handoff if the link expires after 15 minutes. The post says only that links expire.
• Where browser session data is stored and for how long, beyond the idle TTL parameter in the example.

What I would check

These are my untested suggestions.

1. Read the three breaking changes against your project before you upgrade. Search for connectors/ and for any sandbox scope setting.

2. Compare your shell environment with your .env for LANGSMITH_* values.

3. Pick the browser scope deliberately. Thread scope starts clean each time. User scope keeps logins, so decide who should be able to use them.

4. Test a handoff on a throwaway account, including what the agent does if nobody completes it within 15 minutes.

5. Check that the agent handles a failed login after hand back, since the post says it checks the page to see whether it worked.

6. Try one async subagent on a harmless task and watch what happens when it finishes while the agent is busy, idle and waiting on an approval.

7. Read resolveUser carefully if your agent acts for different people in Slack. It decides whose permissions the tools see.

What I would not conclude

• That handoff makes browser use safe. It keeps the password out of the model's context. Page content is still untrusted input.
• That async subagents are cheaper or faster. The post gives no measurements.
• That the beta is stable. LangChain calls it public beta and removes features in this release.
• That the Slack handlers are final. The post labels them experimental.

Frequently asked questions

What is new in Managed Deep Agents v0.10?

Browser use with a human handoff, async subagents, thread origins, a Slack Stop button, experimental Slack handlers, bring your own Slack app and resolveUser.

How does the login handoff work?

The agent calls browser_handoff with a reason. You open a link to the remote browser, sign in, and click Hand back. The link expires after 15 minutes, per the post.

Do async subagents block the main agent?

No. Per the post, they run on their own thread and the agent keeps talking to the user, and they notify the agent when they finish.

What breaks when I upgrade?

The post lists removal of connectors.mcp() and the connectors/ layout, removal of the sandbox scope option, and a change in environment variable precedence.

Where do MCP servers go now?

In tools/mcp.ts or tools/mcp.py, per the post.

Is it production ready?

The post says public beta.

Does the browser keep logins between conversations?

By default no. With scope="user", logins carry across a signed-in person's conversations.

Sources

All read on October 30, 2026.

• Managed Deep Agents v0.10: Browser use and asynchronous subagents (LangChain, October 29, 2026)

Not read: the linked docs on browser use, runtime and Slack channels, the package and its source, and any pricing pages.