`dots`: The Open-Source Browser That Tries to Look Like a Person
A lean Python wrapper on top of a patched Firefox engine, `dots` treats web automation as an identity problem. Its real trick is making one seed behave like one consistent human across fingerprint, input, and session state.
- `dots` is interesting because it treats browser automation as an identity problem, not a clicking problem.
- Its strongest move is pushing stealth into the Firefox engine, where web pages cannot inspect the usual JavaScript-layer tells.
- The repo stays thin on purpose, using a wrapper to pin behavior, surface the right UI, and hand off most work to the underlying MCP stack.
- Its tradeoff is coherence over breadth, which makes it sharper than general browser libraries but more dependent on one tightly controlled engine path.
The browser is the bottleneck
Most web agents do not fail because the model is dumb. They fail because the browser looks wrong. A site sees WebDriver signals, fingerprint mismatches, impossible input timing, or a session that behaves like software instead of a person.
That matters because the modern web increasingly checks for consistency, not just capability. If your browser says one thing in its headers, another in its GPU profile, and something else in its typing rhythm, the agent is exposed before the model has a chance to help.
The README says the quiet part plainly: "When a web agent fails, the model is rarely why. The page never loaded, a challenge appeared, the login expired, the click did not land. All of that happens in the browser, before the model gets to think." Source
`dots` makes identity the primitive
The core move in `dots` is to treat a browser like a persona, not a process. One seed generates a coherent identity across screen size, user agent, fonts, GPU traits, timezone, locale, mouse motion, typing rhythm, and session state.
Why the wrapper is so thin
`dots` is not trying to reimplement the browser stack. It sits in front of invisible-playwright-mcp, pins behavior tightly, and gives users a branded entry point that drops them into the right UI and environment automatically.
[project]
name = "dots"
version = "0.1.0"
[project.dependencies]
invisible-playwright-mcp = "==0.70.2"
# THE WHOLE PRODUCT IS THIS LINE.
That is a distribution strategy as much as a software choice. The thin wrapper keeps the public surface simple while the engine underneath stays locked to a specific internal API and browser behavior.
The CLI is doing less than you think
The command entry point in src/dots/cli.py mostly delegates. Its job is to make sure the user lands in the UI workflow by default, with the environment context intact, instead of forcing them to know the underlying package layout.
from invisible_playwright_mcp import cli as mcp_cli
def main():
# Reuse the underlying CLI, but steer users into the UI path.
mcp_cli.main(args=["ui"])
That restraint is the point. The repo acts less like a framework and more like a carefully opinionated front door.
The repo tests its prose like code
One of the stranger signals in the project is its validation workflow. The CI and hooks do not just check code paths. They also check claims and English prose, which says a lot about how the maintainer wants the product to read, not just run.
That is unusual, but it fits the repo's thesis. If your product promise is "the browser looks like a person," then sloppy documentation is part of the same trust problem.
How it compares to browser-use and OpenDots
`dots` lives in a narrow but useful corner of the landscape. It is not the most general browser automation library, and it is not trying to be a broad workspace orchestrator or a managed agent platform. It is trying to be the browser that does not look automated.
| Project | Stealth at engine level | Identity persistence | MCP compatible | Scope | Main tradeoff |
|---|---|---|---|---|---|
| dots | Yes, patched Firefox | Yes, seed-driven persona | Yes | Narrow, stealth-focused | Bus factor and engine dependence |
| browser-use | Usually no, Playwright-first | Limited without extra layers | Sometimes via adapters | Broad automation library | More setup to avoid detection |
| OpenDots-style workspace tools | Not the main focus | Persistent workspaces, not fingerprints | Often yes | Orchestration and approvals | Less about hostile-site survival |
| Managed agent platforms | Abstracted away | Platform-managed | Usually yes | Hosted delegation | Less control over browser identity |
The distinction is not just technical. `dots` assumes the browser itself is the product surface that gets judged first, so it invests in consistency before convenience.
The tradeoff is bus factor, not abstraction
A tightly pinned, engine-dependent repo can move fast and stay coherent. It can also become fragile when the underlying browser or dependency shifts.
That tradeoff is not an accident here. `dots` buys focus by accepting maintenance risk, and that is probably the correct bargain if the goal is a browser identity system instead of a general-purpose platform.





