AivexaNewsSearch
AI news for builders and product teamsChecked every hour

Browser Use in Managed Deep Agents

Collected Oct 29, 2026

LangChain announced that its Managed Deep Agents product now gives agents a browser, with tooling tuned for context-efficient browser use and a handoff mechanism that lets a person take over the session. Managed Deep Agents is the offering that lets developers build and deploy agents in LangSmith without running infrastructure: you write the agent's instructions and tools, and LangSmith runs the harness and runtime. As of this release, the browser is hosted by that same managed runtime.

Turning it on takes a few lines. You export a browser object from a browser.py file at the project root, calling define_browser with two settings. The scope argument controls session sharing. In the default, scope="thread", every conversation gets its own browser window with no cookies or logins carried over from another thread. In scope="user", one browser is shared across a signed-in user's threads: each thread still gets its own window so concurrent conversations don't click over each other, but cookies and other browser state are shared, so a sign-in performed in one thread can be reused by a later one. The second setting, idle_ttl_seconds, shuts the browser down after a period without activity, defaulting to 10 minutes, so unused sessions stop incurring cost.

The rationale is straightforward. Booking travel, canceling a subscription or filing a claim happens on sites written for humans clicking through pages, and often there is no API to call. Simple HTTP fetching returns markup before JavaScript renders and cannot click anything. LangChain cites Instinct and Meta's Muse as personal agents already working this way, and notes DataDome observed agentic browser requests rise 4.7x in September alone.

Two use cases are identified. The first is actions an API can't cover, such as flight or restaurant bookings; where an API exists for the task, LangChain says the agent should use the API instead. The second is end-to-end testing, such as checking a frontend change before it merges. A coding agent can start an app in its sandbox, open a form in the browser and click through it. LangChain uses this in Open SWE, its coding agent.

The login problem is handled by browser_handoff. When the agent reaches a sign-in page it calls the tool with a reason, and in LangSmith Studio, the interface for chatting with and debugging agents, the user sees an interactive card with the same browser. The person signs in, clicks Hand back, and the agent resumes already authenticated. Credentials therefore never land in model messages, traces or with a model provider. Handoff ships with every managed browser and works automatically in Managed Deep Agents channels such as Slack. It pairs naturally with user scope, since the sign-in then persists into later threads.

Architecturally, the browser runs in its own LangSmith sandbox, separate from the agent and remote from the developer's machine. What distinguishes it from most remote browsers, per LangChain, is a private link into the agent's sandbox, which is what makes end-to-end testing possible.

The toolset has four pieces. browser_snapshot reads the page's accessibility tree and tags interactive elements with IDs. browser_run acts on the page, either with a batch of actions such as click and fill or with JavaScript against a Playwright-style page object that Stagehand translates into its own commands. browser_screenshot captures the rendered page, and browser_handoff passes control to a human. browser_run carries most of the weight: because it accepts code, an agent can express a whole chain (open, fill, click, verify) in one call and return only what it needs, keeping most page content out of context and long tasks quick.

The tools are built on Stagehand, Browserbase's open source SDK for browser agents. LangChain says it tuned them through its agent development lifecycle, running browser benchmarks, reading LangSmith traces and validating changes with evals. On 100 tasks from WebVoyager, a benchmark of everyday tasks on live websites, the tools passed 90% of tasks for $1.98 in total, the highest pass rate among seven toolsets tested. The nearest, Browserbase's MCP server, passed 89% at nine times the cost.

End-to-end testing needs one extra connection. The app under test runs inside the agent's sandbox, so the browser must reach it. The agent controls the browser through the browser tools, and the browser reaches the app through a localhost bridge: a request to localhost:5173 travels over the private link to port 5173 in the agent sandbox. No public URL is required; localhost refers to the agent's sandbox. The agent starts the app with execute, opens it, clicks real flows and checks what renders. Once a test passes, the agent can save its steps as a test file, since each browser_run call is a fragment of an ordinary Playwright script; later runs replay it with no model calls until the page changes.

My reading is that the benchmark numbers are the most interesting claim for buyers: a small cost difference against an MCP-based approach matters less than the 9x figure, which points to how much overhead page content and round trips add when each action is a separate tool call. Trade-offs worth noting: thread-scoped sessions mean logins don't carry between conversations unless you opt into user scope, and user scope in turn means state is shared across an identity, which raises questions about isolation if one person runs many agents. The idle timeout also imposes a ceiling on long human-in-the-loop pauses unless it is raised. Handoff depends on a UI that can render the browser card, so agents running in other channels rely on the built-in Slack support.

Agents built with open source Deep Agents can use a browser too, where you supply your own hosted option. LangChain says a deeper post on how the browser tools were tested and tuned will follow.

Why it matters: Teams building web-automation agents currently stitch together a remote browser, a driver SDK and their own credential handling; this packages all three behind a config file and a tool list. Developers get a Playwright-compatible path from interactive agent sessions to saved, model-free test scripts, and product teams get a sign-in flow that keeps passwords out of traces and model providers. The open question, as an inference, is how far the 90% figure holds outside a benchmark of everyday sites once logged-in flows and unusual sites enter the picture.

Read at LangChain

Based on reporting from the original publisher. Visit the source for full context and later updates.

Publisher excerpt

Managed Deep Agents now runs a browser for your agent, with tools tuned for context-efficient browser use and a handoff so you can sign in yourself.