Browserbase

Stagehand v4 relocates target management, state and CDP dispatch into a browser extension running beside the page, so remote browsers behave like local Chrome instead of erroring on state that has already moved on. TypeScript, Python and Go SDKs ship at feature parity.

A step-by-step port from Playwright to Stagehand v4, which drives Chromium over CDP with no Playwright dependency. Port as-is first, add explicit waits where auto-waiting carried you, then swap only the most brittle selectors for self-healing act() and extract(), with caching for stable flows.

Browserbase argues the harness, not the model, is what makes an agent ship work: a small familiar tool surface, aggressive context compression, and a tight reasoning loop — extended for the open web with credential brokering, caching, identity and a skill memory.

Why browser automation that works on a laptop breaks on shared cloud runners. The piece attributes the flakiness to Chromium's multi-process architecture, iframe-dense pages spawning extra renderers, and memory pressure under tight CPU and RAM budgets, then argues for separating browser from runner.

The case for code mode: expose a handful of typed capabilities in an execution environment and let the model compose them in a language it already knows, filtering large responses before they reach context rather than wrapping every action in a bespoke tool call.

An independent benchmark of Microsoft's Fara-7B computer use model across 595 WebVoyager tasks, run on deterministic browsers with human verified scoring and up to five retries. The small model outperformed comparable open source models on accuracy, cost and latency.

A build pattern for web automation that survives the web: Stagehand resolves elements semantically instead of by CSS selector, and Temporal wraps each step in durable execution so network failures and DOM changes cause a retry rather than a lost run.

A taxonomy of browser agents across four levels of agency, from natural-language steps inside a program-controlled flow to a model directing the entire task loop, with code samples per level and the situations where each is the right fit. Includes a short history of scripted to agentic browsing.

Stagehand can now call models through a Browserbase-managed gateway: one API key, one bill, and model names passed as plain strings. Browserbase fronts the upstream provider cost and bills tokens at market price, so swapping models stops being a provisioning exercise.

Chrome Canary 150 adds real tab metadata to CDP TargetInfo: active state, pinned state, tab group and containing window. The post walks through why the old heuristics (newest target, forcing activateTarget, injected focus listeners) broke background browser agents, and how the patch landed.

Rather than grading whole agent tasks, this narrows evaluation to a checkable question: did the instruction produce the expected action? Stagehand serializes a merged DOM and accessibility tree to a model and gets back a concrete selector and action, which makes per-instruction regression tests poss

A technical explainer on AWS's Firecracker microVM technology, contrasting Linux container isolation (namespaces, cgroups, seccomp) with full VM isolation, and showing how microVMs strip away legacy PC hardware emulation to get near-container boot speed with VM-grade kernel isolation.

Deciding whether a browser agent actually succeeded is its own research problem. Universal Verifier separates process from outcome and controllable from uncontrollable failures across non-overlapping rubric criteria, reaching human-level agreement and near zero false positives.

Browserbase outlines seven recurring problems financial-services teams hit deploying browser agents: defensible audit trails, session identity surviving re-auth, verified access past bot-gating, human approval gates, and regulator-grade data controls.

Browserbase splits out the execution engine behind Stagehand into its own API: prompts get translated into browser commands server-side, every action is logged with the LLM request, response and cache status, and repeated workflows can replay cached actions instead of re-reasoning.

Stagehand splits browser automation into atomic act/extract/observe calls plus a separate agent() for multi-step work, pulls structured data from the Chrome accessibility tree instead of raw DOM, and exposes itself over MCP so Claude or Cursor can drive a browser directly.

Stagehand is moving from Playwright to direct Chrome DevTools Protocol control. The post explains the seams that forced it: test-oriented actionability checks costing throughput, absent frame IDs breaking per-frame routing, and page-scoped CDP sessions being too coarse.

Browserbase consolidates the browser agent stack behind a single API key: managed browsers, agent identity, Search and Fetch for web data, Functions for sandboxed execution, a Model Gateway so Stagehand can use any model, and session-level observability.

How Stagehand caches browser actions: it stores the resolved selector plus prompt and action config server-side, revalidates that the page still matches before replaying, and skips inference on a hit — up to ~80% faster on a second run. Credentials are excluded, and misses are described plainly.

A field guide to browser agents against systems with no API. The durable patterns: resolve selectors at run time from intent rather than the DOM, persist cookies and local storage so the agent resumes a session instead of re-authenticating cold, and treat sensitive-data boundaries and human handoffs

A step-by-step on handing an agent a real browser over MCP: what the Playwright MCP server advertises as tools, how to run it against a browser on your own machine while developing, and when to point the same tool contract at a hosted cloud browser with managed proxies and session logs.

A Browserbase engineering blog post tracing the history of neural networks from the 1957 Perceptron through reinforcement learning to modern multimodal models, arguing that today's vision-language models can perceive screens, reason, and act like humans, forming the basis of 'computer use agents' that automate software without needing APIs.

An end-to-end pattern for agent-run engineering: each PR gets a preview deploy, a cloud browser session logs in and exercises the feature with vision and DOM, and a session replay lands on the PR before the agent merges. Includes how authentication across ephemeral environments is handled.

Browserbase explains Typesafe's Jev decision models: typed, probabilistic Choice/Score/Noul primitives claimed to be 20-200x faster and 40-400x cheaper than LLM calls, with a worked customer-support example and Stagehand integration notes.