# Motorika: Fine motor skills for AI agents

Across 191 Claude Code runs, my Chrome tool tied Playwright MCP overall and was clearly faster on forms and a shop checkout.

- Author: Laszlo Csiki (https://www.linkedin.com/in/laszlo-csiki-7ba454108/)
- Published: 2026-10-28
- Kind: Article
- Page: https://x2labs.ai/notes/motorika

**TL;DR**

- I built my own browser tool for AI agents: Motorika. It gives an AI full control of a real Chrome, so it can click, type and fill forms on its own.
- I tested it with real Claude Code agents: 191 runs, 8 browser tools, 5 tasks. It had the best average, 26.3 s and $0.127 per task. Microsoft’s Playwright MCP is a near tie at 26.6 s and $0.131, Claude in Chrome took 37.7 s and $0.167.
- It’s clearly ahead on forms and on a shop checkout. On reading a content page, Playwright and Claude in Chrome are still a cent or two cheaper... so not a clean sweep.

Our AI agents spend a surprising part of their day in a browser... checking a deploy, filling a form, reading a thread before I reply to it. By agent I mean an AI that doesn’t only answer questions but does the work itself: opens the page, clicks, types.

The tools we had for this were slow, and each one was missing something I needed. So I built my own, for my colleagues and me, and called it Motorika. The name comes from the Hungarian *finommotorika*, fine motor skills. The model is the brain, Motorika gives it the hands: the clicks, the keystrokes, the form fills.

Technically it’s an MCP server. MCP is the standard way to give an AI model new tools, and this one hands it a whole Chrome.

## Why I started

First I tried what everybody uses: Microsoft’s Playwright MCP, BrowserMCP and Claude in Chrome. Each one works... and each one fell short somewhere.

**Too many round trips.** On the form task, Playwright needed 5 tool calls, Motorika 3 (median of 5 runs each). Every call is one more round where the AI reads the result and decides what to do next, and those rounds are where the time and the money go.

**Too much text.** After a simple click, Playwright sends back about 250 characters about the page. Mine sends 33 (in a separate small test, median of 20 clicks on a local test page). Sounds small, but multiply it by every step of a task.

**One tab at a time.** BrowserMCP drives the one tab you connected, and it can’t open a new one.

**No video.** I wanted agents to check a video: grab frames at given times, read the captions. None of the tools I tried could do that.

**My real browser, or nothing.** BrowserMCP and Claude in Chrome work in my everyday Chrome, with every login I have. I wanted a separate browser for the agents, one I log into on purpose.

So the goal became full control of Chrome for an agent, and “fast” got three meanings I can actually measure: a quick answer per action, short answers, and fewer rounds with the model.

## What it can do

Motorika gives an agent 22 tools over one Chrome. The ones that make the difference:

**Real work in several tabs.** It opens, switches and closes tabs, and it can work on a tab in the background without bringing it to the front. Every element the agent sees gets a short label like `e12`, and that label knows which tab it lives in. So an agent can work on three sites in one call.

**A whole form in one call.** `fill_form` fills every field, picks the options, attaches a file and submits. In the small test (2026-10-23, build 4aaec31, median of 20 runs each), 8 fields plus submit took one call and 277 ms; Playwright needed 2 calls and 658 ms.

**It tells what changed, not the whole page.** A click answers in a few lines: did the page change, did a new tab or a dialog open, did a download start, did an error show up.

**Several steps at once.** With `batch` the agent sends a few steps in one call, so the AI thinks once instead of five times.

**Video.** List the videos on a page, play, pause, jump to a time, change the speed, grab frames, read the captions. Embedded players work too.

**Reading.** The text of a page, a search for a phrase, the structure of the page, and screenshots the agent can click on by position.

**And the rest of the toolbox:** keyboard, scrolling, drag and drop, hover, uploads, downloads, dialog boxes, console and network logs, and `evaluate` for anything else.

**With or without a window.** It starts its own Chrome by default, visible or hidden, and it can also connect to a Chrome that’s already running.

**One browser for every session.** I usually have several Claude Code sessions open at once. They all share one agent browser with my logins, each with its own tabs.

## How it works

Each Claude Code session starts its own small Motorika server, and all of them drive the same Chrome. The important parts, in plain words:

**Nothing is open to the network.** The servers talk to Chrome and to each other only inside my own computer, and the channel between them only my user account can open. If the first server exits, the next one takes over, and the logins stay.

**The agent sees a short list, not the whole page.** A small helper inside every page turns it into compact lines, one per element that matters, each with a short label like `e12`. The agent just says “click e12”, and the label knows its own tab.

**Every action waits, then reports.** After a click, Motorika waits until the page calms down (with hard time limits), then answers with what changed. After opening a new page it adds a short summary of what’s on screen, at most 6,000 characters.

**A web page can’t give orders to the agent.** Every page summary is marked as untrusted, and the page text is quoted, so it can’t pretend to be Motorika talking. Passwords the agent typed are blanked out of everything it reads back: page text, error messages, script results and addresses. A base64 or case-changed copy can still slip through, so it’s not perfect yet.

This is what an agent sees of a login form:

```plaintext
- form "Login" e7
  - textbox "Email" e8 type=email required
  - textbox "Password" e9 password value=<redacted>
  - button "Sign in" e12
```

And a click that stays on the same page comes back as two lines, not a page dump:

```plaintext
[t1] clicked e31 button "Add to cart"
→ alert "1 item added to your cart"
```

## What I measured

I ran every browser tool I had through the same five tasks: Motorika, Playwright MCP (also in its screenshot-only mode), Chrome DevTools MCP, agent-infra, the Puppeteer reference server, Claude in Chrome and BrowserMCP. Overall, Motorika and Playwright are a near tie... the difference shows up per task.

**Average per task, over all five tasks**

Mean of each tool's per-task means, 5 runs per task. BrowserMCP is left out: the benchmark stopped it early.

| Tool                            | Tasks passed | Time per task | Cost per task |
| ------------------------------- | ------------ | ------------- | ------------- |
| Motorika                        | 25/25        | 26.3 s        | $0.127        |
| Playwright MCP                  | 25/25        | 26.6 s        | $0.131        |
| Chrome DevTools MCP             | 25/25        | 27.2 s        | $0.175        |
| agent-infra                     | 25/25        | 29.7 s        | $0.133        |
| Claude in Chrome                | 25/25        | 37.7 s        | $0.167        |
| Playwright MCP, screenshot-only | 25/25        | 38.1 s        | $0.208        |
| Puppeteer reference server      | 20/25        | 50.1 s        | $0.179        |

**Per task: Motorika, Playwright MCP and Claude in Chrome**

Median time and cost per task, 5 runs each.

| Task             | Motorika        | Playwright MCP  | Claude in Chrome |
| ---------------- | --------------- | --------------- | ---------------- |
| T1 form          | 13.3 s · $0.087 | 21.1 s · $0.108 | 35.3 s · $0.125  |
| T2 Wikipedia     | 14.7 s · $0.119 | 19.7 s · $0.103 | 30.5 s · $0.110  |
| T3 three tabs    | 17.4 s · $0.100 | 20.0 s · $0.091 | 22.6 s · $0.104  |
| T4 shop checkout | 32.9 s · $0.153 | 38.4 s · $0.173 | 70.7 s · $0.253  |
| T5 long thread   | 21.5 s · $0.178 | 15.9 s · $0.169 | 29.2 s · $0.234  |

A run passes only if the final answer is right and the agent’s log shows a browser tool actually produced it, checked by a script, not by me. Time is the wall time of the whole agent run, cost is what Claude Code reports for it. The first table averages each tool’s per-task means, so every task weighs the same. The second shows medians, because one slow run can pull a mean a lot. Motorika had one: on the long thread my network changed mid-run, that run took 160.9 s, and I kept it in.

The five tasks: **T1** fills and submits a form, **T2** searches Wikipedia and reads an article, **T3** opens three sites in tabs and works on each, **T4** logs into a local test shop and places an order, **T5** answers three questions about a long Hacker News thread.

Each task ran 5 times per tool, done by a real Claude Code agent (Claude Opus 5.5). I mixed the order so any drift hit every tool equally, and each tool got one untimed warm-up first. Claude in Chrome and BrowserMCP drive my real, signed-in Chrome, so those two ran in a visible window, on a different day from the other six.

Setup: 26 and 27 October 2026, Claude Opus 5.5 in Claude Code (its version wasn’t recorded for these runs), Chrome 155, and Chrome 156 for the two real-Chrome tools. Motorika at commit ef2f9a0, Playwright MCP 0.0.83, Chrome DevTools MCP 1.12.0, agent-infra 1.2.29, the Puppeteer reference server 2025.5.12, BrowserMCP 0.1.3 and the Claude in Chrome extension 1.0.102.

And to be fair: I built Motorika, I wrote the tasks, and I tuned it after the first run. The other tools ran as they ship.

**Where it wins:** on forms and on the shop checkout, Motorika was clearly faster and cheaper than Playwright. Those are the tasks where agents click and type the most. In a separate small test (2026-10-23, an earlier build), a single click answered in 127 ms; Playwright took 527 ms (median of 20 clicks each).

**Where it loses:** on the Wikipedia article, Playwright is about 1.5 cents cheaper per task, its screenshot-only mode about 3 cents (14.8 s and $0.087, median of 5 runs) and Claude in Chrome about 1 cent. On the tabs task, Playwright is about a cent cheaper. On the long thread, Playwright was faster by median too, 15.9 s against 21.5 s.

Claude in Chrome also solved all 25. It was slower than Motorika on forms, Wikipedia and the checkout. On tabs and the long thread it was also slower by median (22.6 s against 17.4 s, and 29.2 s against 21.5 s), but over five runs those gaps weren’t clear. BrowserMCP had a rough day. Twice on the form task its typing timed out while the keystrokes were still arriving, those runs hit the 6-minute limit, and the benchmark stopped it after 16 runs. When it worked, it was competitive on Wikipedia, at 24 s. It can’t open a second tab, and neither can the Puppeteer reference server.

The first run made Motorika look expensive... and that was on me. After every page load it sent back a summary of the page, and on Wikipedia that filled the whole 20,000-character limit. I cut it to what’s on screen, at most 6,000 characters, and on the Wikipedia and tabs tasks the text it sent back fell by 61% and 76%, counted in characters before and after the change. My cost per task went from $0.204 to $0.119 on Wikipedia and from $0.170 to $0.095 on tabs (2 runs each), while Playwright stayed at about $0.10 and $0.09 in the same session. So that one change closed most of the cost gap.

## What’s still ahead

It’s not finished yet, and I don’t want to pretend it is.

**A cleaner benchmark.** These numbers come from one laptop that was busy with my other sessions, five tasks and one model, and the two real-Chrome tools ran a day after the rest. I want a rerun on a quiet machine, with a second model... hopefully soon.

**A safer page helper.** Today the helper inside the page runs in the page’s own JavaScript and protects itself by checking everything it gets. Moving it into a separate, isolated space would take a whole class of attacks off the table.

**Where it still loses.** Typing is about 0.1 s slower per action (107 ms against 7 ms for Playwright, median of 20 on a local test page, 2026-10-23, build 4aaec31), because Motorika waits for the page to settle and report what happened. Starting up takes about 0.8 s, against 0.6 s for agent-infra, the fastest (median of 10 cold starts, same test). And on reading a content page, Playwright and Claude in Chrome are still a cent or two cheaper per task.

What it won’t do: get around bot detection, hide that it’s automated, or solve CAPTCHAs. I left those out on purpose.

## Open source

Motorika is open source under the MIT license: [github.com/X2Mobile/motorika-mcp](https://github.com/X2Mobile/motorika-mcp). Try it, break it, and tell me what’s missing.

One piece of advice before you try it: the agent browser is a separate profile you log into yourself, so keep your bank, your main email and your admin accounts out of it.

## My take

I’m keeping it, and I’ll keep working on it. If your agents fill forms, click through a checkout or work in several tabs at once, give it a try, that’s where the difference showed up. If they mostly read pages, Playwright MCP is still a bit cheaper and works fine, so I wouldn’t switch just for that.
