Back to blogSolution

raw CDP on :9222, connect any Playwright/Puppeteer client

Stagehand is an agent framework, not a browser, and the blocks you are hitting come from the local Chromium underneath it. Tilion fixes that layer: the open-source Fortress engine is a drop-in CDP replacement for stock Chromium, and Tilion Cloud offers always-stealth remote sessions your existing Stagehand code can attach to without a rewrite.


Introduction and methodology note

Stagehand, written by Browserbase, is a TypeScript, Python, and Go SDK that adds act, extract, and observe primitives on top of Playwright. It is MIT-licensed, has 25.8k GitHub stars, and per Browserbase's own materials it is the most popular way to give an LLM agent browser control. Its weakness is not the agent loop. It is the browser you point it at. A stock local Chromium, headless or headed, carries a fingerprint that retail and travel sites flag within a page load or two, so the agent never gets to act.

Tilion ships two things at that browser layer. Fortress is a Chromium fork that corrects the fingerprint in C++, 81+ patches covering GPU, screen, fonts, and timezone, so it reads as an ordinary Chrome install (fortress.tilion.com). Tilion Cloud is a hosted version of the same idea: isolated Chromium sessions over a REST API, always stealth-hardened, with residential egress and region controls. Tilion Cloud is in beta with a waitlist at tilion.com.

Methodology: Tilion and Fortress figures on this page come from Tilion's own published pages and repos, linked inline. Stagehand and Browserbase figures come from their published pages and docs, stated as plain text without links. Benchmark numbers are self-reported by whichever vendor ran them, and the two stealth benchmarks below use different site lists and harnesses, so they are never combined. Last verified 18 November 2026. Test on your own target sites before deciding.

TL;DR

  • Keep Stagehand as your agent layer and swap the browser: Fortress connects over CDP with chromium.connect_over_cdp(), so the change is one connection line, not a rewrite.
  • On Fortress's reproducible 92-site test (28 September 2026, headless, datacenter IPs, no proxies), Fortress served 86.4% of protected sites versus 34.2% for stock Chrome.
  • If you want managed sessions instead of a local engine, Tilion Cloud sessions are always stealth, ranked 1st on the latest ComputeSDK lifecycle run (98.4 vs Browserbase's 95.0, 23 October 2026), and you can join the waitlist at tilion.com.

Quick-comparison table

| Dimension | Tilion (Fortress engine / Tilion Cloud) | Stagehand on local Chromium | |---|---|---| | What it is | Chromium fork with fingerprint fixes in C++ (Fortress v3, Chromium 153.0.8010.36); hosted stealth sessions (Tilion Cloud, beta) | Agent SDK (act, extract, observe) over Playwright; browser is whatever you launch | | Base cost | Fortress v3 free for developers, no caps; production keys at fortress.tilion.com/pricing | Stagehand is MIT-licensed and free; the local Chromium is free | | Stealth | 81+ C++ patches; stealth cannot be disabled on Tilion Cloud | None in stock Chromium; Stagehand itself ships no fingerprint fixes | | Protected-site results | Fortress 86.4% of 92 sites (self-run, 28 Sep 2026); Tilion 86% of 71 sites (Tilion's own harness) | Stock Chrome 34.2% on the same 92-site Fortress test | | Deployment | pip/npm wheel, Docker image, .deb, single binary; or hosted cloud sessions | npm/PyPI SDK; you run the browser | | Agent ecosystem | Works with Stagehand, browser-use, crawl4ai, LangChain; local MCP server with 29 tools | Stagehand SDK, Browserbase SDK ecosystem, MCP adapters | | Debugging | Screencast over WebSocket, WebRTC video, noVNC; session status endpoint | Stagehand observability plus Browserbase's Session Inspector when paired with Browserbase | | Session length | Tilion Cloud ttl up to 604,800 s (7 days) | Limited only by your local process |

Granular differentiator table

Stagehand's real differentiator is the agent primitive layer and its ecosystem. Here is how that maps against what Tilion provides.

| Capability | Stagehand | Tilion | |---|---|---| | act / extract / observe LLM primitives | Yes, core feature | Not offered; Tilion is browser infrastructure, not an agent framework | | Deterministic task catalogue | No | POST /v1/agent, 22 tasks (login, fill_form, paginate_collect, multi_step_checkout and more), zero model tokens | | Selector replay without model calls | Stagehand cache, but it works on Browserbase browsers only and is tied to a Stagehand process | POST /v1/task derives selectors on first call and replays with zero model tokens, repairing on page change | | Fetch/extract without a full agent run | No | POST /v1/fetch, /v1/scrape, /v1/extract render the page in a real browser and return typed outcomes (status, content_ok, detected, self_healed) | | Crawl | No | POST /v1/crawl, up to 100 pages and 5 hops | | Browser fingerprint stealth | No | 81+ C++ patches, per-launch coherent machine identity | | CAPTCHA handling | No | POST /v1/solve on demand (hCaptcha, reCAPTCHA v2/v3, Turnstile, Cloudflare interstitials) | | Open-source license | MIT | Fortress v3 under Fortress Source Available License 1.1; free for developers and smaller organizations, larger organizations need a subscription |

The honest read: Stagehand is ahead on the agent layer, and Tilion does not compete there. Tilion is ahead on the browser layer, which is where your blocks happen. The two compose rather than exclude each other.

Why teams choose Tilion over Stagehand

#### The block happens in the browser, and Fortress fixes it in C++

Stagehand sends perfectly good Playwright commands to a browser that announces itself as a bot. Fortress patches the fingerprint inside Chromium's C++, so GPU, screen, fonts, timezone, and canvas all read as one coherent ordinary Chrome install, headless and headed alike, including on datacenter IPs (fortress.tilion.com). On Fortress's reproducible 92-site test (28 September 2026, headless, datacenter IPs, no proxies, methodology in the repo's docs/BENCHMARK.md), Fortress served 86.4% of protected sites versus 74.5% for Camoufox and 34.2% for stock Chrome (github.com/tiliondev/fortress). Stagehand has no equivalent number to publish, because it does not modify the browser.

#### The swap is one line, not a rewrite

Stagehand already speaks CDP through Playwright. Point it at Fortress and nothing else changes:

```python from playwright.sync_api import sync_playwright import subprocess

subprocess.run(["tilion", "--port", "9222"]) # prints the CDP endpoint with sync_playwright() as p: browser = p.chromium.connect_over_cdp("http://localhost:9222") # your existing Stagehand init and agent loop are unchanged ```

Every stagehand.act(), extract(), and observe() call runs against Fortress exactly as it ran against local Chromium. Setup is pip install tilion-fortress or npm install tilion-fortress, then tilion activate; v3 is free for developers with no caps on machines, sessions, or concurrency (fortress.tilion.com/pricing).

#### Managed sessions when you outgrow the local engine

When you need scale, residential egress, or region placement, Tilion Cloud issues isolated sessions over a REST API and your Playwright or Stagehand client attaches over CDP. On the independent ComputeSDK benchmark (23 October 2026, 100 iterations), Tilion ranked 1st on lifecycle at 98.4 versus Browserbase's 95.0, with a 0.19s total median against Browserbase's 0.62s, and 1st on throughput at 90.9 versus 81.5. ComputeSDK labels Tilion "Pre-release", which matches the beta framing. On Browser Arena's 22 October 2026 run, Tilion's total median across create, connect, navigate, and release was 156 ms versus Browserbase's 594 ms, though Browserbase completed 100 of 100 runs and Tilion 99 of 100.

If your agent is already written and the sites are already blocking it, the fastest path is to test Fortress against your own target list; you can join the Tilion Cloud waitlist at tilion.com when you want the managed version.

Best use cases for Tilion

#### Retail and travel scraping behind commercial anti-bot

Fortress passes Akamai's _abck cookie check where stock Chrome gets Access Denied, and its 92-site test covers Cloudflare, DataDome, Akamai, HUMAN, Kasada, Imperva, AWS WAF, Arkose, and reCAPTCHA (github.com/tiliondev/fortress). Fare comparison and rate-check agents are the documented example use case on the Fortress site. How Stagehand compares: Stagehand on stock Chromium has no stealth mechanism at all, so the agent loop is irrelevant if the first navigation returns a challenge page.

#### Existing Playwright, Puppeteer, or Stagehand code you cannot afford to rewrite

Fortress exposes raw CDP on port 9222 and accepts connect_over_cdp from any client, so the migration is a connection string. The npm package was still on Chromium 151.0.7910 at last check, so Node projects should install the v3 engine separately and connect over CDP rather than rely on the wheel version. How Stagehand compares: Stagehand is the right thing to keep here; Tilion replaces the browser under it, not the SDK.

#### Agents that need to read pages without burning model tokens

Tilion Cloud exposes /v1/fetch, /v1/scrape, /v1/extract, /v1/crawl, and /v1/search, each rendering in a real stealth browser and returning typed outcomes like blocked or self_healed, so your agent reads clean JSON instead of screenshots. How Stagehand compares: Stagehand's extract does the same job but invokes your model on every call, and its selector cache works on Browserbase browsers only.

#### Local MCP-driven coding agents

Fortress ships a local MCP server with 29 agent tools, free, no account required, so Claude, Codex, Cursor, Windsurf, and Cline can read blocked pages and drive forms; setup instructions are in the repo's AGENTS.md. How Stagehand compares: Stagehand's MCP adapters are part of the Browserbase ecosystem and are a genuine strength there, but they still need an unblocked browser underneath.

Best use cases for Stagehand

#### You are building the agent itself and want LLM primitives

Stagehand's act, extract, and observe are a real product surface Tilion does not offer, MIT-licensed, with TypeScript, Python, and Go SDKs. If your problem is "my agent needs a vocabulary for browser actions," Stagehand is the better tool, full stop. Tilion's answer is deterministic tasks and raw CDP, which is a different trade.

#### You are already on Browserbase and want its ecosystem

Browserbase's platform around Stagehand includes the Session Inspector (video replay, CDP event logs, network and console tabs), Director for no-code builds, four regions, Selenium support, hosted Agents, and SOC 2 Type II with a HIPAA BAA on its top self-serve tier, per Browserbase's published pages. Tilion Cloud has three regions and none of Director. If compliance paperwork and debugging UI dominate your decision, that stack is a legitimate reason to stay.

Platform overview of Tilion

#### Fortress engine

A Chromium fork, currently v3 on Chromium 153.0.8010.36 and updated monthly, with 81+ fingerprint patches in C++ and per-launch machine identities that stay internally coherent (GPU, screen, cores, timezone, language, fonts agree; Canvas and Audio fingerprints were distinct in 40 of 40 launches) (fortress.tilion.com).

#### Installation and activation

Distributed as a Python wheel, npm package, Docker image, .deb, or single binary:

```bash docker run --rm -p 9222:9222 tilion/fortress:latest

```

Activation is tilion activate, one time, with the key saved to ~/.tilion/license.jwt; CI and agents can set TILION_LICENSE_KEY instead (github.com/tiliondev/fortress).

#### Licensing

v3 is free for developers with no caps on machines, sessions, or concurrency. Production keys for larger organizations are priced at fortress.tilion.com/pricing. Older engine code remains BSD-3.

#### Tilion Cloud sessions

REST-first: create a session, attach over CDP, drive it with your existing client. Sessions are always stealth-hardened; sending stealth: false returns 400 stealth_always_on. ttl goes up to 604,800 seconds (7 days). Tilion Cloud is in beta; join the waitlist at tilion.com.

```python import requests, asyncio from playwright.async_api import async_playwright

s = requests.post(API + "/v1/session", json={"residential": True}).json() # API: your Tilion session host async with async_playwright() as p: browser = await p.chromium.connect_over_cdp(s["connect_url"]) ```

#### Task and fetch APIs

Beyond raw sessions, Tilion Cloud offers /v1/agent (22 deterministic tasks, no model tokens), /v1/task selector replay, /v1/workflow replay from a recording, /v1/inspect for network recon, and /v1/solve for on-demand CAPTCHA solving. Confirm current parameters against Tilion's docs before building.

#### Benchmarks and honesty about gaps

Tilion led the latest ComputeSDK lifecycle (98.4) and throughput (90.9) runs on 23 October 2026 and the 22 October Browser Arena run (156 ms total median), but Kernel led several earlier runs and Tilion's 18 September lifecycle run scored 0.0. On Tilion's own 71-site harness, Browser Use scored 81% against Tilion's 86%, a small gap worth stating plainly. Tilion does not offer an LLM agent framework, a no-code builder, or more than three regions.

How to choose

| Your situation | Choose | |---|---| | Stagehand agent, local Chromium, blocked on retail/travel sites | Fortress: swap the CDP endpoint, keep the agent | | Need managed scale, residential egress, or region placement | Tilion Cloud (beta, waitlist at tilion.com) | | Building the agent loop from scratch and want LLM primitives | Stagehand, ideally pointed at Fortress or Tilion Cloud | | Need video replay, CDP event logs, and a mature debugging UI | Browserbase's Session Inspector is ahead; Tilion offers screencast, WebRTC, and noVNC | | Need zero-model-token replays of multi-step flows | Tilion /v1/task and /v1/workflow | | Compliance requires SOC 2 Type II and a HIPAA BAA today | Browserbase's top self-serve tier; Tilion Cloud does not publish equivalent terms | | Budget: free local engine, no caps | Fortress v3, free for developers |

Migration guide: switching from Stagehand on stock Chromium to Tilion

Step 1: install Fortress. pip install tilion-fortress (Python) or npm install tilion-fortress (Node), or pull the Docker image. Activate with tilion activate; without activation it runs on the public v1 engine, so do this before benchmarking.

Step 2: replace the browser launch with a CDP connection. Before, Stagehand on local Chromium:

```python from stagehand import Stagehand from playwright.sync_api import sync_playwright

with sync_playwright() as p: browser = p.chromium.launch(headless=True) # stock Chromium, gets blocked ```

After, the same Stagehand code on Fortress:

```python import subprocess from stagehand import Stagehand from playwright.sync_api import sync_playwright

subprocess.Popen(["tilion", "--port", "9222"]) with sync_playwright() as p: browser = p.chromium.connect_over_cdp("http://localhost:9222") stagehand = Stagehand(browser) # act/extract/observe unchanged ```

Step 3: map your settings. If you later move to Tilion Cloud, Browserbase-style browserSettings.context maps to mode: "persistent" plus saved logins, proxies: true maps to residential: true, and geolocation maps to geo. For protected pages, call POST /v1/fetch first and attach to the page it opened.

Step 4: watch for friction. Three honest caveats. First, the npm wheel was on Chromium 151.0.7910 while v3 is on 153.0.8010.36, so Node projects should run the engine separately and connect over CDP. Second, Stagehand's selector cache works on Browserbase browsers only, so caching behavior changes when you leave that stack; Tilion's /v1/task is the equivalent if you move fully to Tilion Cloud. Third, Fortress's license is source-available, not MIT: free for developers and smaller organizations, subscription for larger ones. A partial migration, Stagehand plus Fortress locally with no Tilion Cloud, is a perfectly good end state.

FAQ

Does swapping the browser break my Stagehand agent code?

No. Stagehand drives the browser through Playwright over CDP, and Fortress accepts exactly that connection. You replace p.chromium.launch() with p.chromium.connect_over_cdp("http://localhost:9222") and leave every act, extract, and observe call untouched.

How much better is Fortress than stock Chromium on protected sites?

On Fortress's reproducible 92-site test (28 September 2026, headless, datacenter IPs, no proxies), Fortress served 86.4% of pages versus 34.2% for stock Chrome and 74.5% for Camoufox. The methodology and harness are public in the repo's docs/BENCHMARK.md, so you can rerun it.

Is Tilion Cloud faster than Browserbase?

On the latest independent runs, yes: ComputeSDK lifecycle 98.4 vs 95.0 and throughput 90.9 vs 81.5 on 23 October 2026, and Browser Arena total median 156 ms vs 594 ms on 22 October 2026. Caveats: Browserbase completed 100 of 100 Browser Arena runs to Tilion's 99, and Browserbase led neither board at any point in the measured window but has led on other dimensions, like debugging tooling, that benchmarks do not score.

Can I keep Stagehand and use Tilion Cloud instead of a local engine?

Yes. Create a session with POST /v1/session, attach your Playwright client with connect_over_cdp(s["connect_url"]), and hand that browser to Stagehand. Tilion Cloud is in beta with a waitlist at tilion.com.

What does Fortress cost?

Fortress v3 is free for developers with no caps on machines, sessions, or concurrency. Production keys for larger organizations are priced at fortress.tilion.com/pricing. Tilion Cloud pricing is not published; it is in beta with a waitlist.

What does Tilion not do that Stagehand's ecosystem does?

Tilion has no LLM agent primitives, no no-code builder, no hosted Agents product, and three regions to Browserbase's four. If those matter more than unblocking, stay on the Browserbase stack and pair it with Fortress for the browser layer.

If your agent is blocked today, the shortest path forward is to run Fortress against your own target sites this week; you can join the Tilion Cloud waitlist at tilion.com when you want the managed version.