Claude Code vs Cursor vs Opencode: 1.42M MCP Tool Calls Compared

187 MCP clients, 1.42M agent tool calls, three very different usage shapes. The data POV on which coding agent actually uses browser-automation MCP the most.

Himanshu Saleria

•June 13, 2026•

MCPAI Coding AgentsClaude CodeCursorOpencodeData

Published 2026-06-13 · Last updated 2026-06-13 · 11-minute read

Every "best AI coding tool" listicle ranks Claude Code, Cursor, and Codex on developer experience. None of them tell you what these agents actually do once you hand them browser-automation power.

We do, because we run the wire.

Our open-source playwright-mcp server has handled 1.42 million agent tool calls since November 2025, from 6,687 distinct IDs across 187 distinct MCP clients. Every call carries which coding agent is on the other end. Three clients lead, and they lead in three very different ways. This is the data POV on which AI coding agent actually uses an MCP browser the most, and what each one does with it.

TL;DR

• 187 distinct MCP clients drive our playwright-mcp server. The agentic-testing channel is fragmented across the entire coding-agent ecosystem.
• Claude Code wins on install base: 980 distinct users, 355,654 tool calls. Broadest reach, moderate per-user volume.
• Opencode wins on session intensity: 358 users, 558,343 tool calls. Heaviest per-user volume, by a wide margin.
• Cursor-vscode is the editor-integrated casual: 601 users, 47,721 tool calls. Broad install, light per-user usage.
• Codex-mcp-client is the dedicated niche: 316 users, 62,589 tool calls. Moderate volume, dedicated tooling.
• 3,416 untagged early-adopter users (older clients predating tagging) still outnumber every named segment by headcount.

Bottom line. Across 1.42M agent tool calls on our open-source MCP server, Claude Code leads on user adoption (980 distinct users), opencode leads on session volume (558K events from 358 users), and cursor-vscode is the casual editor-integrated client (601 users, 48K events). No single coding agent owns the channel; 187 distinct clients drive the server.

For the broader category context behind these numbers, see the State of AI QA 2026 report.

Which AI coding agent uses MCP the most?

It depends on whether you measure by users or by volume, and the two answers point at different products.

By distinct users, Claude Code is the clear leader: 980 IDs in the dataset. By total tool-call volume, opencode is the leader: 558,343 events. Cursor-vscode sits between them on users (601) but well below on volume (47,721 events). Codex-mcp-client is a smaller, dedicated niche (316 users, 62,589 events).

Here is the top-of-the-table cut, ranked by event volume:

Three reads jump out.

Opencode users behave like agent-loop operators. 1,560 events per user, on average, is the signature of long autonomous sessions. Not a developer running one verification per git push. A handful of opencode IDs in the dataset crossed 100K tool calls each.

Claude Code users behave like in-the-loop verifiers. 363 events per user is a healthy number but a different shape. Closer to a developer using the MCP to check "did this work?" inside a coding session, then closing the loop, then opening it again tomorrow.

Cursor-vscode users behave like editor-integrated casuals. 79 events per user is the smallest per-user number among the top four. The MCP is one tab among many inside an IDE that already does a hundred other things. Casual, broad install, light usage.

The chart at this point in the Playwright MCP 230K downloads post shows the same client mix as a stacked bar; if you want the visual, go there.

What does each MCP client actually do with browser access?

Each client's tool-call shape tells you what work it's doing. Browser inits, screenshots, code execution: these are the verbs that separate the casual from the autonomous.

The aggregate signature across all 1.42M calls is sharp. 643,424 screenshots vs 264,268 browser inits = 2.4 screenshots per session. Combined DOM-snapshot calls (text + interactive + full) totalled ~100K, less than a sixth of screenshot volume. Agents drive by sight, not by DOM tree.

That pattern holds across clients, but the intensity varies.

Opencode: the autonomous-loop runner

Opencode's 1,560 events per user signals sustained agent activity. These aren't verification bursts, they're long, autonomous runs where the agent screenshots, decides, acts, screenshots again, often for hundreds of cycles inside a single session. A QA Lead at a Japanese-language SaaS in our customer interview set described their own MCP test generator as "give the agent a fixture, let it run." That's the opencode profile in our telemetry.

The implication for buyers: if you're picking a coding agent to drive sustained browser automation against a known surface (a regression flow, a scrape, a data-collection job), the user data suggests opencode users have already figured this out. Their per-user numbers are the highest in the dataset.

Claude Code: the broad in-session verifier

Claude Code's 363 events per user with 980 IDs is the broadest healthy use of the MCP we see. A developer working inside Claude Code asks the agent to verify a change, the agent fires init_browser, runs a few screenshots, decides, reports back. The session ends, the developer commits the change, the next session opens tomorrow.

It is the modal pattern in agentic browser testing 2026: short verification loops inside a coding session, repeated daily. Not a regression suite. Not a 1,000-step autonomous run. The dev's git push loop, automated one step further left.

Cursor-vscode: the editor-integrated casual

Cursor-vscode's 79 events per user is the lightest in the top four. The pattern matches the IDE-integrated reality: the MCP is wired up, the developer remembers it exists, uses it once or twice, returns to the keyboard.

That's not a knock on Cursor. It's a read on what happens when an MCP server is one feature among many inside an IDE that ships its own AI loop. The developer's default behavior is to use Cursor's built-in capabilities first, the MCP second. Volume per user falls accordingly.

Codex-mcp-client: the dedicated niche

Codex-mcp-client's 198 events per user across 316 IDs is the smallest segment in the top tier, but the per-user volume is real. Dedicated MCP clients (built specifically to wire Codex into an MCP server) attract a smaller, more intentional cohort. They installed the client, they use it.

The long tail behind these four (Gemini CLI, Cline, Windsurf, Trae, Kiro, GitHub Copilot, Antigravity, Qwen, LM Studio) fills the rest of the 187-client count. None individually large, collectively meaningful.

Key takeaways

• Claude Code leads on user adoption (980 distinct users) but moderate per-user volume. Broad in-session verification use.
• Opencode leads on session volume (558K events from 358 users): 1,560 events per user, the signature of autonomous loops.
• Cursor-vscode is the editor-integrated casual: broad install (601 users), light per-user usage (79 events).
• No single coding agent owns the agentic-testing channel. 187 distinct MCP clients drive the server.

Which AI coding agent should you pick for browser testing?

If you're evaluating coding agents primarily on developer experience, the answer is whichever one your team already uses. If you're evaluating them on how they drive an MCP browser, the data points at three different answers for three different jobs.

For in-session verification inside a coding loop ("did my change work?"), Claude Code's 980-user adoption and 363-event session shape is the most-validated pattern. It is what the most developers are actually doing.

For sustained autonomous browser automation ("let the agent run this end-to-end overnight"), opencode's 1,560-events-per-user signature is the strongest signal. Power users running long loops, validated by volume.

For light, editor-native automation alongside other AI features, Cursor-vscode's broad install (601 users) and casual per-user usage (79 events) match the typical IDE-embedded experience.

For dedicated single-purpose Codex automation, codex-mcp-client gives a moderate-volume (198 events per user) path with a smaller, intentional cohort.

The honest framing: for agentic testing specifically, the MCP client matters less than the agentic capability of the loop you put around it. The MCP server is the API. The coding agent is the IDE. The work that actually catches bugs (deciding what to test, asserting on the right thing, repairing when the UI changes) sits a layer above the client choice. The State of AI QA 2026 report walks through what that work looks like in n=41 mid-market SaaS interviews, and the Anatomy of an AI-Authored Test breaks down the 12.2% AI-driven step share inside real tests.

What's missing from these numbers

A few honest disclosures before you cite them.

distinct_id is a session identity, not a verified human. Heavy IDs are almost certainly automated agent loops, not unique developers. Treat per-user counts as directional, especially for opencode where the top IDs cross 100K events each.

The untagged bucket is real. 3,416 IDs predate our client-tagging instrumentation. They are early adopters of playwright-mcp who showed up before the category had standard tagging. By headcount, that bucket is bigger than every named client, but we can't tell you what they were running.

Volume is not quality. Opencode's 558K events tell us power users exist. They don't tell us those tests passed, found real bugs, or held up over time. Our MCP events carry no pass/fail field yet. The reliability story sits in the Playwright MCP 230K downloads post and in our public reliability dashboard, neither of which segments by client.

Median user runs 8 calls and disappears. Across all clients combined, 41% of users tried 5 events and never came back. That activation cliff is the bigger story than any client comparison. The What-to-Test Gap is one reason: knowing which test to write is harder than running the test.

For the buyer-side checklist on evaluating any AI testing tool against this kind of telemetry, see How to evaluate AI testing tools.

What this means if you're building or buying

Devs ship faster than QA tests. We close the gap.

If you're shopping an AI testing tool wired to an MCP, the data above says four useful things:

1. The coding agent layer is fragmented. 187 clients in the wild means no vendor-lock-in to a single agent is wise. Pick a tool that runs across Claude Code, opencode, Cursor, and the long tail.
2. Per-user volume varies 20x between agents. Opencode users average 1,560 events. Cursor users average 79. Pick the agent that matches your loop shape (sustained autonomous vs in-session verification vs casual IDE).
3. The MCP client choice is downstream of the test-design choice. Whether you screenshot, snapshot the DOM, or assert with AI is the real engineering decision. The client wraps the loop; the loop decides what to test.
4. Activation, not adoption, is the constraint. 41% of MCP users drop off after 5 events. The vendor that wins is the one that converts the 8-call median user into a 100-call returning user.

The outcome we promise: release confidence at engineering velocity, without hiring SDETs. The pitch is only honest if the tool clears the activation bar, regardless of which coding agent you wire it to.

If your team is in the N-3 Lag pattern (automation perpetually three sprints behind dev) and you'd rather skip the SDET hire than ship slower, an audit of your current QA gap against these patterns is the first call.

Run My Audit →

About this post

Author: Himanshu Saleria, Co-founder & CEO, QAby.AI. Background in QA-led product engineering at scale; running QAby.AI's customer research, telemetry analysis, and product. LinkedIn.

Published 2026-06-13 · Last updated 2026-06-13 · 11-minute read

Cross-reads from this dataset

• State of AI QA 2026: the full mid-market QA report behind these numbers, including the MCP telemetry section
• What 230,000 Playwright MCP Downloads Taught Us About AI Agents in CI/CD: the full activation-cliff and screenshot-over-DOM story
• Anatomy of an AI-Authored Test: what real users build, step by step
• The What-to-Test Gap: the deeper bottleneck behind activation drop-off
• How to evaluate AI testing tools: buyer-side checklist

External cross-validation:

• qabyai/playwright-mcp on GitHub: the open-source MCP server behind this data
• Microsoft @playwright/mcp on npm: category cross-comparison
• Model Context Protocol spec: the protocol every client in the dataset implements

Frequently asked questions

Which MCP client has the most users for browser testing?

Claude Code leads on distinct users with 980 IDs in our playwright-mcp telemetry, more than 2.7 times opencode's 358. The next-largest named clients are cursor-vscode (601 users), codex-mcp-client (316), mcp generic (189), and Visual Studio Code (126). 187 distinct clients in total drive the server, so headcount is fragmented across the coding-agent ecosystem.

Which MCP client has the most tool-call volume?

Opencode dominates volume with 558,343 tool-call events from just 358 distinct users (about 1,560 events per user), the signature of sustained autonomous loops. Claude Code is second with 355,654 events from 980 users (363 events per user). Together they account for over 60% of all tool-call volume in the 1.42M-event dataset.

Is Claude Code better than Cursor for browser testing?

Different shapes of use. Claude Code users average 363 tool calls each, consistent with in-session verification inside a coding loop. Cursor-vscode users average 79 tool calls each, consistent with light editor-integrated automation alongside Cursor's other AI features. Pick Claude Code if your loop is "verify each change"; pick Cursor if the MCP is one tab among many.

What is opencode and why do its users run so many MCP calls?

Opencode is an open-source AI coding agent. In our data, opencode users average 1,560 tool calls each, around 20 times the Cursor average. A handful of opencode IDs crossed 100,000 events apiece, consistent with autonomous loops running unattended (regression flows, scrapes, long-form data jobs). Opencode users skew toward sustained agent activity, not interactive verification.

How does codex-mcp-client compare to Cursor and Claude Code?

Codex-mcp-client is a dedicated MCP client for Codex (rather than an IDE integration). It logged 62,589 tool calls from 316 users (198 events per user). Compared to Claude Code (363) and Cursor (79), it sits in the middle: smaller, more intentional cohort than Claude Code, more dedicated workflow than Cursor's editor-integrated casual use.

Should I pick an MCP client based on my coding agent or my testing goal?

Pick the coding agent first, then check that it has working MCP support. The data shows the agentic-testing channel is fragmented across 187 clients and no vendor owns it. For sustained autonomous browser automation, opencode users lead by volume; for in-session verification, Claude Code leads by adoption; for editor-integrated casual use, Cursor fits naturally. The MCP server (the API) matters less than the agent loop wrapped around it.

Where can I see the source data behind this comparison?

The telemetry sits behind our open-source qabyai/playwright-mcp server, instrumented since November 2025. The methodology and broader category context (1.42M agent tool calls, 5,904 distinct domains, the activation cliff, the screenshot-over-DOM finding) is in the Playwright MCP 230K downloads post and the State of AI QA 2026 report.