# We made Claude Code 2x faster and 1.8x cheaper in Chrome

By Arjun Jain · Published 2026-10-07 · Updated 2026-10-07
Source: https://pre.dev/blog/we-made-claude-code-2x-faster-and-1-8x-cheaper-in-chrome/

![Each task's median run, added up: the pre.dev MCP finished the 8 tasks in 1:56, Claude in Chrome in 3:58 (replayed 16x faster)](/blog/content/images/2026/10/ec89403cab2db4fe0e73f55b.gif)

Swap Claude in Chrome for the pre.dev MCP, and Claude Code gets **2x faster and 1.8x cheaper** on browser tasks. Same agent, same model, same Chrome.

Coding agents are getting good at using a browser: reading a dashboard, filling in a form, checking the page they just built. When an agent does that work, a lot of the wait isn't the model thinking. It's the browser tool.

So we raced two of them. Same agent (Claude Code), same model (Claude Sonnet 5.5), same Chrome, the same 8 everyday tasks, 3 times each. The only thing we changed was the browser tool: Anthropic's [Claude in Chrome](https://code.claude.com/docs/en/chrome), or the [pre.dev MCP](https://github.com/predotdev/mcp), our open source one, which we built with pre.dev. (Its Chrome tools are free; its plain-words actions and cloud runs use pre.dev credits.)

Add up each task's median run and the 8 tasks took 1:56 with the pre.dev MCP and 3:58 with Claude in Chrome. Both got every task right, every time.


## Faster on every task

![Faster on every task, up to 2.8x](/blog/content/images/2026/10/914597a101b4d5a106a75e1f.png)

The pre.dev MCP was faster on all 8 tasks, from 1.3x on reading a list on Hacker News to 2.8x on browsing three pages of a store.

![121 seconds back across the 8 tasks](/blog/content/images/2026/10/bd446b9db68cc87abe4951f0.png)

![The pre.dev MCP was faster on all 8 tasks](/blog/content/images/2026/10/07ac82e31b70b22fcf80a227.png)

## Not a fluke

Medians can hide a lot, so here is every single run.

![All 48 runs, not just the medians](/blog/content/images/2026/10/d41f85deeaab073100ea906d.png)

Head to head, the pre.dev MCP finished first in 22 of the 24 matchups. One of its two losses was a run where the agent chose pre.dev's cloud browser instead of the local Chrome.

![The pre.dev MCP finished first in 22 of 24 runs](/blog/content/images/2026/10/74f760e119ff9b511a8f7fc8.png)

## It adds up

All 24 runs added up: about 12 minutes of browser work became about 6.

![12:06 of browser work became 6:09](/blog/content/images/2026/10/9bd9c75f1677547b611e0536.png)

It was cheaper on every task too: $2.47 against $1.28 for all 24 runs at API prices, because the agent spends fewer, smaller steps getting the same answer.

![Cheaper on 8 of 8 tasks](/blog/content/images/2026/10/9a56516bc4b02c82a1b90704.png)

## Why it's faster

- **It reads the page instead of looking at it.** The pre.dev MCP hands the agent the page as short text, with a ref like `e13` on every button and field. Claude in Chrome also reads text, but its agent took 17 screenshots in 6 of its 24 runs and sometimes clicked by pixel position.
- **Less waiting outside the model.** Across the 24 runs, the time spent outside the model (browser tools and startup) was 349 seconds with Claude in Chrome and 95 with the pre.dev MCP.
- **Fewer steps to get going.** The pre.dev MCP opens a page in any of your Chrome profiles in one call. Claude in Chrome's tools ask the agent to set up its tab group first, which it did in 18 of 24 runs.

![Screenshots or text](/blog/content/images/2026/10/17a47038744e1e953e2d398f.png)

![Most of the gap is outside the model](/blog/content/images/2026/10/f4347e3b8947e953b81942bc.png)

## Built with pre.dev

We built the pre.dev MCP with pre.dev itself. pre.dev's coding agent, in the [pre.dev CLI](https://docs.pre.dev/cli/overview) and [on the web](https://pre.dev), built it with us and kept iterating on it until it was this fast.

Want to build your own tools the same way? Install the CLI:

```bash
curl -fsSL https://pre.dev/install | bash
```

Then type `/chrome` in it, and it gets these Chrome tools too.

## Set it up in your agent

![One command, every agent](/blog/content/images/2026/10/9054b59eba8bfb346742b6c0.png)

One command signs you in to pre.dev (free), adds the server to the agents it finds on your Mac, and connects to your Chrome:

```bash
npx -y @predotdev/mcp setup
```

Then restart your agent and ask it: *"List my Chrome profiles and the tabs I have open."* The first time, turn on remote debugging at `chrome://inspect/#remote-debugging` (setup walks you through it). Chrome then asks **Allow remote debugging?**, and again after each restart: click **Allow**.

**Already using Claude in Chrome?** Run the setup command above, then type `/chrome` in Claude Code and turn off **Enabled by default**. Your Chrome profiles and logins carry over, because the pre.dev MCP drives the Chrome you already use. The [switching guide](https://docs.pre.dev/browser-agents/switch-from-claude-in-chrome) has a tool-by-tool table and a prompt you can paste into your agent.

Prefer to add it yourself? It's one line in most agents:

**Claude Code**

```bash
claude mcp add --scope user predev -- npx -y @predotdev/mcp
```

**Codex**

```bash
codex mcp add predev -- npx -y @predotdev/mcp
```

**Hermes**

```bash
hermes mcp add predev --command npx --args -y @predotdev/mcp
```

(answer `Y` to turn on its tools)

**Pi** (0.99 or newer)

```bash
pi mcp add predev -- npx -y @predotdev/mcp
```

**GitHub Copilot CLI**

```bash
copilot mcp add predev -- npx -y @predotdev/mcp
```

**OpenClaw**

```bash
openclaw mcp set predev '{"command":"npx","args":["-y","@predotdev/mcp"]}'
```

**Cursor, Windsurf, Antigravity, Cline, Kiro and other `mcpServers` files** (desktop apps like Claude Desktop can't always find `npx`, so run `setup` for those: it writes full paths)

```json
{
  "mcpServers": {
    "predev": { "command": "npx", "args": ["-y", "@predotdev/mcp"] }
  }
}
```

**Any agent without MCP** (Aider, scripts, anything that can run a command):

```bash
npx -y @predotdev/mcp tools
npx -y @predotdev/mcp call chrome_open '{"profile":"Personal","url":"https://example.com"}'
```

**The pre.dev CLI**: type `/chrome`.

Zed, Goose, Continue, OpenCode, VS Code, Gemini CLI, Qwen Code, Factory Droid, Amp and the rest are in the [setup guide](https://github.com/predotdev/mcp#setup-for-every-agent).

## When Claude in Chrome is the better pick

The 8 tasks are public, read-only and text-heavy on purpose, so they don't test a few things Claude in Chrome does well:

- **Visual work.** Checking a layout or working in a canvas app needs eyes, and screenshots are central to how Claude in Chrome works.
- **Guardrails.** It has [permission modes and a classifier that checks actions](https://support.claude.com/en/articles/12902428-using-claude-in-chrome-safely) before they run.
- **No Node.js.** It's a browser extension, and it's already in Claude's apps on [every paid Claude plan](https://claude.com/blog/claude-in-chrome-generally-available). The pre.dev MCP needs Node.js 22, and we've only tested it on macOS.

![What you get with each](/blog/content/images/2026/10/5bf6b3590c579433dff8390f.png)

## How we tested

![One agent, two sets of browser tools](/blog/content/images/2026/10/5a8f0dd8bfdf27e3c2291cf9.png)

Each run was a fresh `claude -p` session on Claude Sonnet 5.5 with one set of browser tools, the same prompt for both ("Use only your browser tools." and the task, naming no Chrome profile), no personal settings, and both sides alternating. A script checked every answer. We ran it twice: in an everyday Claude Code setup (the numbers above) and with nothing loaded but the browser tools, where the pre.dev MCP was 1.8x faster.

![Faster in both setups](/blog/content/images/2026/10/ae22c380dac36778630ce0b3.png)

A few things worth knowing:

- **Each run was a fresh session,** so per-session setup counts every time. In one long session it's paid once.
- **How we compare.** Each task's time is the median of its 3 runs, each headline ratio is the median of the 8 per-task ratios. The race adds up each task's median run; the other totals add up every run.
- **Cost is what Claude Code reports at API prices.** It leaves out the few pre.dev credits the pre.dev side used: 3 plain-words actions and one cloud browser run.
- **Permissions.** Claude Code ran each side's browser tools without asking. We can't tell from the logs whether the extension's own action checks ran.
- **Versions:** Claude Code 2.1.292, Claude in Chrome extension 1.0.98, `@predotdev/mcp` 2.0.2, all on October 7, 2026.

The full method, every run's results and the harness to reproduce it are on [GitHub](https://github.com/predotdev/mcp/tree/main/bench), along with [Anthropic's Claude in Chrome docs](https://code.claude.com/docs/en/chrome) we checked our claims against.

---

About pre.dev: pre.dev is the Long Horizon Coding Agent: it plans, builds and verifies software for hours, in the browser or the terminal. pre.dev Labs also sells RL Tasks to frontier AI labs for model post-training: hard, verified coding tasks built from licensed private production code, each shipped as a runnable Harbor container with a graded verifier, a hidden reference solution and solver trajectories, at 1,000+ new tasks a month. https://pre.dev