docs: Improve remote browser page flow and structure

Lead with why (no sandbox compute wasted, zero install, CAPTCHA handling,
parallel browsing), show two approaches upfront, then streamlined walkthroughs.

Author: beran-t

docs/use-cases/remote-browser.mdx

@@ -4,14 +4,27 @@ description: "Use Kernel cloud browsers with E2B sandboxes for web scraping, app
 icon: "globe"
 ---
 
-[Kernel](https://www.kernel.computer/) provides cloud browsers — remote Chromium instances you can control programmatically via [CDP](https://chromedevtools.github.io/devtools-protocol/). Combined with E2B sandboxes, your agents can browse the web without running a browser locally.
+[Kernel](https://www.kernel.computer/) provides cloud browsers — remote Chromium instances your agents can control via [CDP](https://chromedevtools.github.io/devtools-protocol/) (Chrome DevTools Protocol).
 
-E2B provides pre-built sandbox templates with the Kernel SDK and Playwright already installed:
+## Why use a remote browser?
 
-| Template | Includes | Use case |
+Running a browser inside the sandbox works, but offloading it to Kernel has real advantages:
+
+- **No sandbox compute wasted on Chrome** — Chromium is resource-hungry. Kernel runs it on dedicated infrastructure so your sandbox CPU and memory stay available for your agent's actual work.
+- **Zero installation** — no need to install Chrome, Chromium, or Playwright binaries in your sandbox template. Kernel provides the browser remotely.
+- **Built-in CAPTCHA and bot detection handling** — Kernel browsers support stealth mode, residential proxies, and browser profiles that persist cookies and sessions across runs.
+- **Parallel browsing** — spin up multiple Kernel browsers simultaneously without multiplying sandbox costs.
+
+## Two approaches
+
+E2B provides pre-built sandbox templates with the Kernel SDK already installed:
+
+| Template | What's included | Best for |
 |---|---|---|
-| `kernel-browser` | Kernel SDK, Playwright | Programmatic browsing, screenshots, scraping |
-| `kernel-agent-browser` | Kernel SDK, Playwright, Browser Use | Autonomous AI agent browsing |
+| `kernel-browser` | Kernel SDK, Playwright | Programmatic browsing — screenshots, scraping, app previews |
+| `kernel-agent-browser` | Kernel SDK, Playwright, Browser Use | Autonomous AI agents that browse on their own |
+
+Both templates connect to Kernel browsers over CDP. The difference is whether *you* write the browsing logic or an *LLM agent* decides what to do.
 
 ## Prerequisites
 
@@ -30,29 +43,26 @@ E2B_API_KEY=e2b_***
 KERNEL_API_KEY=kernel_***
 ```
 
-## App preview with Kernel
+## Programmatic browsing
+
+Use this approach when you know exactly what pages to visit and what to do on them — taking screenshots, scraping data, or generating previews.
 
-Deploy a web app inside a sandbox, get a public URL, then use a Kernel browser to visit every route, capture screenshots, and produce a preview report.
+This example deploys a web app inside a sandbox, gets a public URL, then uses a Kernel browser to screenshot every route.
 
 <Steps>
-<Step title="Create the sandbox">
-Start an E2B sandbox using the `kernel-browser` template. No local browser binary is needed — Kernel provides the browser remotely.
+<Step title="Create the sandbox and deploy your app">
+Start a sandbox with the `kernel-browser` template, write your web app into it, and start the server.
 
 ```python
+import os
 from e2b import Sandbox
 
 sandbox = Sandbox.create(
     "kernel-browser",
     envs={"KERNEL_API_KEY": os.environ["KERNEL_API_KEY"]},
     timeout=300,
 )
-```
-</Step>
-
-<Step title="Deploy the web app">
-Write a FastAPI application into the sandbox and start it as a background process on port 8000.
 
-```python
 sandbox.files.write("/home/user/app.py", FASTAPI_APP)
 sandbox.commands.run(
     "pip install --break-system-packages fastapi uvicorn",
@@ -66,19 +76,14 @@ sandbox.commands.run(
 ```
 </Step>
 
-<Step title="Get the public URL">
-E2B exposes any sandbox port as a public HTTPS endpoint.
+<Step title="Get the public URL and browse with Kernel">
+E2B exposes any sandbox port as a public HTTPS endpoint. A script inside the sandbox creates a Kernel browser, connects via Playwright CDP, and screenshots each route.
 
 ```python
 host = sandbox.get_host(8000)
 app_url = f"https://{host}"
-```
-</Step>
 
-<Step title="Browse with Kernel">
-A script running inside the sandbox creates a Kernel cloud browser, connects via Playwright CDP, and visits each route to take screenshots.
-
-```python
+# This runs inside the sandbox
 from kernel import Kernel
 from playwright.sync_api import sync_playwright
 
@@ -95,8 +100,8 @@ with sync_playwright() as pw:
 ```
 </Step>
 
-<Step title="Generate the preview report">
-After visiting every route, the script writes a JSON report with page titles and screenshot paths. The orchestrator reads it back from the sandbox.
+<Step title="Read the results">
+After visiting every route, read the report back from the sandbox.
 
 ```python
 import json
@@ -251,9 +256,9 @@ if __name__ == "__main__":
     main()
 ```
 
-## Agent browser with Browser Use
+## Autonomous agent browsing
 
-Add the [Browser Use](https://docs.browser-use.com/) framework to give an LLM autonomous control over a Kernel browser. The agent sees the page via screenshots and decides what to click, type, and navigate — you just give it a task.
+Use this approach when you want an LLM to decide what to click, type, and navigate. The [Browser Use](https://docs.browser-use.com/) framework connects an LLM to the Kernel browser — the agent sees the page via screenshots and autonomously completes tasks.
 
 This requires an additional LLM API key (Anthropic, OpenAI, or other [supported model](https://docs.browser-use.com/customize/supported-models)):
 
@@ -263,7 +268,7 @@ ANTHROPIC_API_KEY=sk-ant-***
 
 <Steps>
 <Step title="Create the sandbox">
-Start an E2B sandbox using the `kernel-agent-browser` template, which includes Browser Use on top of the Kernel SDK and Playwright.
+Use the `kernel-agent-browser` template, which includes Browser Use on top of the Kernel SDK and Playwright.
 
 ```python
 from e2b import Sandbox
@@ -279,8 +284,8 @@ sandbox = Sandbox.create(
 ```
 </Step>
 
-<Step title="Write the agent script">
-The agent script creates a Kernel browser, connects Browser Use to it, and runs a task autonomously.
+<Step title="Write and run the agent">
+The agent script creates a Kernel browser, connects Browser Use, and runs a task autonomously. You just describe what you want done.
 
 ```python
 AGENT_SCRIPT = '''
@@ -291,7 +296,6 @@ from browser_use import Agent, Browser, ChatAnthropic
 async def main():
     kernel = Kernel()
     kb = kernel.browsers.create()
-
     browser = Browser(cdp_url=kb.cdp_ws_url)
 
     agent = Agent(
@@ -306,17 +310,7 @@ asyncio.run(main())
 '''
 
 sandbox.files.write("/home/user/agent_task.py", AGENT_SCRIPT)
-```
-</Step>
-
-<Step title="Run the agent">
-Execute the agent inside the sandbox. The agent will autonomously browse, click, type, and navigate to complete the task.
-
-```python
-result = sandbox.commands.run(
-    "python3 /home/user/agent_task.py",
-    timeout=180,
-)
+result = sandbox.commands.run("python3 /home/user/agent_task.py", timeout=180)
 print(result.stdout)
 ```
 </Step>
@@ -427,9 +421,7 @@ if __name__ == "__main__":
 
 ## Kernel MCP tools
 
-The [Kernel MCP Server](https://mcp.onkernel.com/mcp) exposes 10 tools over the Model Context Protocol. Connect any MCP-compatible client — no installation needed.
-
-Install for CLI tools:
+The [Kernel MCP Server](https://mcp.onkernel.com/mcp) exposes 10 tools over the Model Context Protocol, letting MCP-compatible clients manage browsers without any SDK installation.
 
 ```bash
 kernel mcp install --target <target>  # Supports Cursor, Claude Desktop, VS Code, etc.
@@ -458,30 +450,17 @@ Authentication uses OAuth 2.0 via Clerk.
 
 ## Deploying Kernel skills
 
-An agent running inside the sandbox can use the Kernel CLI to create, deploy, and invoke browser automation skills — turning any one-off workflow into a persistent, reusable automation.
+An agent running inside the sandbox can use the Kernel CLI to package any browser workflow as a persistent, reusable automation.
 
 ```python
-# Agent deploys a reusable browser automation skill
+# Create a new skill from a template
 sandbox.commands.run("kernel create --name price-checker --language python --template browser-use", cwd="/home/user")
-# ... agent writes the automation code ...
+# Deploy it
 sandbox.commands.run("kernel deploy main.py --env-file .env", cwd="/home/user/price-checker")
-# Later, invoke the deployed skill
+# Invoke it later
 sandbox.commands.run('kernel invoke price-checker check --payload \'{"url": "https://example.com"}\'')
 ```
 
-## Key concepts
-
-| Concept | Detail |
-|---|---|
-| **E2B templates** | `kernel-browser` and `kernel-agent-browser` — pre-built with the Kernel SDK and Playwright |
-| **Public URL** | `sandbox.get_host(port)` returns an HTTPS hostname for any sandbox port |
-| **Background process** | `sandbox.commands.run(..., background=True)` starts a web server without blocking |
-| **Kernel browser** | `kernel.browsers.create()` spins up a remote Chromium; connect via `kb.cdp_ws_url` |
-| **CDP connection** | Playwright's `connect_over_cdp()` drives the remote browser with full API access |
-| **Browser Use** | Agent framework that connects an LLM to Playwright for autonomous browsing |
-| **Kernel MCP Server** | Hosted at `https://mcp.onkernel.com/mcp` — 10 MCP tools for browser management and automation |
-| **Kernel Skills** | `kernel create` + `kernel deploy` packages browser automations as persistent, invokable skills |
-
 ## Related guides
 
 <CardGroup cols={3}>