While software providers build systems without programmatic access, agentic browser requests jump 4.7x in September alone, according to DataDome data. Business processes stall when autonomous tools encounter interfaces that lack traditional endpoints. Running headless browsers to bypass these architectural gaps introduces heavy operational overhead, forcing engineering teams to absorb massive infrastructure costs for compute, memory-intensive DOM rendering, and maintenance of fragile automation scripts.
Applications built for human navigation create operational barriers. Fetching target pages with curl produces raw HTML before JavaScript renders, leaving agents unable to click elements or execute tasks. Relying on graphical interfaces instead of clean APIs forces teams to trade reliability and speed for universal coverage, multiplying token usage and execution time as models parse visual layouts rather than structured JSON payloads.
Managed Deep Agents v0.10 is out today, introducing browser use and async subagents to address this architectural gap.
Sandbox Execution and Scoped Sessions
Managed Deep Agents runs the browser in its own LangSmith sandbox and adds browser tools to the agent automatically. By default, each conversation gets its own browser, which is reused across turns and starts with no cookies or logins from other threads, mitigating state drift across distributed legacy environments.
With scope equal to user, each signed-in person gets one browser whose logins carry across all of their conversations, so the agent only asks them to sign in to a site once.
The agent hands the window to you instead, so your password never ends up in the model's messages or traces.
Authentication barriers historically blocked autonomous workflows. The agent calls browser_handoff with a reason and explains why it needs the user, ensuring corporate credentials remain secure outside the LLM context window and respecting strict security boundaries when handling session timeouts.
Asynchronous Delegation
Previously in Managed Deep Agents, subagents ran inline, so the agent called one and waited for its answer. This execution model created bottlenecks during long-running operational workflows, consuming valuable compute resources while waiting on UI interactions.
With Managed Deep Agents v0.10, developers can run subagents asynchronously by adding async to a subagent definition. Every served agent also gets a background copy of a general-purpose subagent.
An async subagent shares the agent sandbox and picks up files the agent already wrote. Runtime thread tracking ensures that every thread carries a record of where it started, such as a Slack thread, and who is on it, allowing engineering teams to maintain traceability and manage state across distributed legacy environments as headless browser autonomy scales.
Why it matters
A 4.7-fold surge in browser agent traffic over September makes it clear how software without program access actually gets handled — by parsing visual frontends instead of clean data streams. Engineering teams pay for that workaround with fragile automation scripts and heavy compute costs, burning time while models inspect page layouts rather than structured JSON. Autonomy still hits authentication barriers, leaning on human handoffs whenever enterprise logins block the flow. Will running asynchronous subagents inside LangSmith sandboxes make headless browser rendering economically viable if legacy software vendors continue to leave their platforms without program access?