Open source computer use agent for devs, the part nobody writes up

The anchor fact

On my disk there are exactly six files that define the fleet. Three Playwright configs and three MCP wrapper configs. They live under ~/.claude/browser-agent-configs/. Here is the smaller of the two reddit files, verbatim:

{
  "browser": {
    "userDataDir": "__HOME__/.claude/browser-profiles/reddit",
    "launchOptions": {
      "args": [
        "--window-position=150,150",
        "--window-size=911,1016"
      ]
    },
    "contextOptions": {
      "viewport": { "width": 911, "height": 1016 }
    }
  },
  "outputMode": "file",
  "imageResponses": "omit",
  "outputDir": "__HOME__/.playwright-mcp/reddit-agent"
}

Sixteen lines. The only field that matters for the multi-agent story is browser.userDataDir. That is a directory Playwright hands to Chromium as the persistent on-disk profile. Cookies, IndexedDB rows, service workers, the CDP cache, all of it lives there. Every subsequent run resumes from that state instead of booting a blank Chromium. That is the difference between a demo and a fleet.

The matching wrapper file reddit-agent-mcp.json turns that config into an MCP server any LLM can call:

{
  "mcpServers": {
    "reddit-agent": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "@playwright/mcp@latest",
        "--config",
        "__HOME__/.claude/browser-agent-configs/reddit-agent.json"
      ],
      "env": {
        "PATH": "__NODE_BIN__:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
      }
    }
  }
}

That is the entire integration surface. command: npx, args: [@playwright/mcp@latest, --config, ...]. No package to vendor, no Dockerfile, no patched Chromium. The twitter and linkedin pairs are byte-identical except for the path and window position.

You can list the whole fleet on disk in one shell:

$ ls ~/.claude/browser-profiles
linkedin   reddit   twitter

$ ls ~/.claude/browser-agent-configs
linkedin-agent.json      reddit-agent.json      twitter-agent.json
linkedin-agent-mcp.json  reddit-agent-mcp.json  twitter-agent-mcp.json

Why every other open source agent guide stops here

Pull up any of the popular open source computer use repos and run their default example. You will get a screenshot of an agent completing one task, beautifully. Then you will close the process, and everything the agent learned about being signed into a real account, dismissing real banners, and clicking real cookie modals evaporates with it. The next run starts blank.

That is fine for a benchmark. It is useless for a developer who actually wants to leave an agent on their machine for a week and come back to find that it has done something useful while staying logged into three different sites without any of them tripping a security check.

Build the fleet, step by step

The whole pattern is five moves. None of them require writing Playwright code yourself. None of them require a custom MCP server. Everything lives in JSON.

Register the agents with your LLM

The MCP wrapper file is what your driver registers. With Claude Code, the call is one line per agent. The same JSON works as input to any other MCP client (Cursor, Continue, a Python or TypeScript runner using the official MCP SDK).

claude mcp add-json reddit-agent \
  --transport stdio \
  "$(cat ~/.claude/browser-agent-configs/reddit-agent-mcp.json | jq '.mcpServers."reddit-agent"')"

# Repeat for twitter-agent and linkedin-agent.
# Now Claude (or any MCP client) sees three browser agents,
# each pinned to its own Chrome profile.

After registration, the LLM sees three browser agents as three distinct MCP servers, each with its own toolset (browser_navigate, browser_click, browser_type, browser_snapshot, browser_evaluate, and so on). A tool call to reddit-agent.browser_navigate is unambiguously routed to the Chromium that has the reddit cookies. A tool call to linkedin-agent.browser_navigate is unambiguously routed to a different Chromium.

What actually happens on one run

Walk through a single reddit post. Cron fires the runner script. The runner asks the LLM for the next action. The LLM calls reddit-agent. The MCP server spawns Chromium with the persistent profile. Chromium loads reddit.com with cookies that have been sitting on disk for weeks. The page comes back already logged in. The LLM clicks, types, posts. The Chromium closes, the cookies stay on disk for the next run.

What each agent gets that single-agent setups miss

The shape of the fleet is six small things, all of them mundane, all of them load-bearing. Each item below is a property a single one-shot computer use demo does not have, and the reason a demo becomes a real production fleet the moment you add it.

The minimal stack

There is nothing under the hood that is not on this list. No custom Chromium build, no patched Playwright, no proprietary orchestrator. Each piece is a thing a dev already has installed.

The isolation rules, in one place

If your fleet ever does something weird (one platform forgets it is logged in, two agents post the same content, a Chromium hangs on launch), one of these rules has been broken. They are short and load-bearing.

What this is not

This pattern is for devs who want to leave a few agents running against sites they own or operate, in their own name. It is not a way to run a thousand fake accounts on someone else's platform. The whole point of persistent userDataDirs is that each one is a real, manually-signed-in human session. That puts a hard cap on scale and a lower bound on responsibility, which I think is the right shape for a personal agent fleet anyway.

It is also not a replacement for a desktop computer use agent if your task lives outside the browser. If you need to drive Figma, Final Cut, or some macOS native app, you want pixel-and-keystroke tools (Anthropic computer use, OpenAdapt, macos-use) rather than DOM tools. The Playwright MCP path is for sites that render in a web browser, which is most of them.

The smallest version you can ship today

Pick one site you want an agent on. Make a singlemysite-agent.jsonwith a userDataDir under your home directory. Make a singlemysite-agent-mcp.jsonthat wraps it. Open Chrome against that userDataDir once and log in. Register the MCP server with your LLM. Have it perform a single, low-stakes action. The whole thing is two files and one npx command. Adding a second agent is the same two files with a different name and a different userDataDir. Nothing else changes.

That is the entire pattern. If you want to see it run end to end on three platforms at once, with the lock layer that prevents two cron jobs from grabbing the same Chrome profile in the same minute, the next deepest piece is the orchestrator writeup linked below.