`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.

8 min read • View on GitHub • More from feder-cr

A wide editorial scene shows a browser at a customs checkpoint. On one side, a generic headless browser is stopped by an inspector scanning for flags, mismatched fingerprints, and automation tells. On the other side, a more coherent browser persona passes through with one identity dossier controlling its screen, input, and fingerprint details. The image explains that web agents are judged by who the browser appears to be, not just by what it clicks.
Most browser automation fails at the border. `dots` tries to solve the border itself.
Key Takeaways

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.

One seed fans out into a coordinated browser identity. The point is not to toggle stealth tricks one by one, but to keep the whole persona internally consistent.

A close-up shows a seed at the center of a mechanical identity machine. Branches from the seed drive screen dimensions, fonts, GPU traits, timezone, locale, mouse motion, and typing cadence, all linked by visible mechanical shafts and gears. The image explains that `dots` treats fingerprint signals as one synchronized system instead of a bag of independent stealth hacks.
The seed is not a randomizer. It is the root of a consistent browser persona.

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.

ProjectStealth at engine levelIdentity persistenceMCP compatibleScopeMain tradeoff
dotsYes, patched FirefoxYes, seed-driven personaYesNarrow, stealth-focusedBus factor and engine dependence
browser-useUsually no, Playwright-firstLimited without extra layersSometimes via adaptersBroad automation libraryMore setup to avoid detection
OpenDots-style workspace toolsNot the main focusPersistent workspaces, not fingerprintsOften yesOrchestration and approvalsLess about hostile-site survival
Managed agent platformsAbstracted awayPlatform-managedUsually yesHosted delegationLess 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.