█

AI/TLDR

Buy me a coffee
Buy me a coffee

invisible_dots

Self-hosted AI agents that each get a QEMU virtual machine of their own, with a desktop, a shell and a patched Firefox built not to look automated

Computer & Browser UseOpen source
Updated
7 Oct 2026
Language
TypeScript, Python, Go
License
MIT

What's new

7 Oct 2026

First CI-built golden image published for invisible_dots, the rebuilt project formerly at feder-cr/dots: each agent (a Dot) now runs in its own QEMU virtual machine with a desktop, memory, skills and approvals, built from source with Node and Go instead of launched with uvx.

IN SHORT

What is invisible_dots?

invisible_dots is a self-hosted alternative to hosted agent products such as OpenAI Dots and Grok Bot. Its unit is a Dot: a persistent AI agent with a computer of its own. It sits in the Computer & Browser Use category of the Agents & Automation tools and is open-source, written in TypeScript, Python, Go and licensed MIT.

Updated Markdown version ↗

Overview

Animated explainer of a Dot at work: asked once to save a shop's invoices every month, it uses a computer of its own, writes the steps down as a skill and sends the total every month
The README's walkthrough: one request becomes a skill the Dot writes for itself and a monthly automation it asks you to approve.invisible_dots README ↗

invisible_dots is a self-hosted alternative to hosted agent products such as OpenAI Dots and Grok Bot. Its unit is a Dot: a persistent AI agent with a computer of its own. You give a Dot a name, a model and a set of permissions, and invisible_dots gives it a hardware-accelerated QEMU virtual machine on your PC (KVM on Linux, the Windows Hypervisor Platform on Windows) with a Linux desktop, a shell, a persistent disk, its own files and browser identities that keep their cookies and logins between tasks. The model is any model on OpenRouter, paid with your own key.

The browser is where the project started. Under its earlier name, feder-cr/dots, it was a single-command web agent; it is now the browser layer of each Dot. That browser is invisible_playwright_mcp, a Firefox patched in C++ with the fingerprint set inside the engine instead of injected into the page, and each identity keeps its own profile and fingerprint. A Dot reads the web only through that browser: it has no web search or fetch tool and no sub-agents.

Around the VMs sits a control plane on your PC that runs the queue, the event log, the approvals and the channels. Every tool belongs to a permission set to allow, ask or deny, and an ask waits in an Inbox, survives a restart and lets that one call run once. A Dot keeps its own notes in `/home/dot/memory` and writes its own `SKILL.md` skills in `/home/dot/skills`, the layout Claude Code reads. You reach it from a web UI, a command line, an HTTP API, Telegram or, opt-in, WhatsApp. The guide calls the project alpha: Linux and Windows on x86-64 only (no macOS), built from source, MIT licensed, with no server of its own and no telemetry.

What it does

  • A computer per agent: a hardware-accelerated QEMU VM with a Linux desktop and a persistent copy-on-write disk that sleeps when idle and wakes for the next message, task or automation
  • A Firefox patched in C++ (invisible_playwright_mcp) as the only browser, with named identities that each keep their own cookies, logins and fingerprint
  • Allow / ask / deny permissions on every tool, with Careful, Balanced and Autonomous presets and an Inbox where approvals wait and survive a restart
  • Memory and skills the Dot writes itself as files in its home folder, plus any MCP server you declare, each behind its own permission
  • A task queue with priorities and start times, and automations the Dot schedules itself (at a time, every interval or a cron expression)
  • Web UI, command line, HTTP API with live events, Telegram and opt-in WhatsApp; a restart or `kill -9` keeps every accepted message and task

Getting started

invisible_dots is built from source. You need Linux or Windows on x86-64 with hardware virtualization on, Node 24+, Go 1.25+, Git, at least 20 GiB free and an OpenRouter key. The guide's quickstart is four commands after the clone.

Linux (Ubuntu 24.04): get the tools and build the command line

bashbash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs git
sudo snap install go --classic
git clone https://github.com/feder-cr/invisible_dots
cd invisible_dots
npm ci
npm run build --workspace @invisible-dots/cli

Get the host ready in one command

`setup --all` builds the guest daemon, installs QEMU and turns on the accelerator, builds the web client, and builds or downloads the Dot's images. Run it as yourself, not as root. If it stops for a restart (Windows) or to add you to the `kvm` group (Linux), do that and run it again: it carries on.

bashbash
node apps/cli/dist/invisible-dots.mjs setup --all

Start the server and create the first Dot

The server runs in the foreground and serves the web client. Open http://127.0.0.2:3000, paste your OpenRouter key on Home, then use Create a Dot.

bashbash
node apps/cli/dist/invisible-dots.mjs server

Or drive it from the command line

In a second terminal: store the key (asked at a prompt, never an argument), write a `dot.yaml` to edit, create the Dot, send it a message and follow its events.

bashbash
node apps/cli/dist/invisible-dots.mjs secret openrouter
node apps/cli/dist/invisible-dots.mjs init
node apps/cli/dist/invisible-dots.mjs create dot.yaml
node apps/cli/dist/invisible-dots.mjs message my-first-dot "List the files in your home folder and say how much disk is free."
node apps/cli/dist/invisible-dots.mjs logs my-first-dot

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

When to use it

  • Reach for it when an agent should keep working over days: its own disk, browser logins, notes and skills persist between tasks
  • Reach for it for recurring browser chores, such as a morning fare check written to a CSV or a monthly invoice download, set up as an automation the Dot asks you to approve
  • Reach for it when web tasks fail on bot detection rather than on reasoning, and you want a browser built not to look automated
  • Reach for it when you want a self-hosted, OpenRouter-backed alternative to hosted agent products, with approvals you answer from the web, the terminal or Telegram

How invisible_dots compares

invisible_dots alongside other open-source computer & browser use tools AI/TLDR tracks, ranked by GitHub stars.

ToolStarsWhat it does
Browser Use★ 121kA Python library that lets agents control a real browser to read pages and complete tasks online from natural-language instructions.
Open Interpreter★ 68.9kA lightweight coding agent that runs code on your own computer to carry out tasks from natural-language requests.
Chrome DevTools MCP★ 57.4kThe Chrome team's MCP server that lets a coding agent control and inspect a live Chrome browser — performance traces, network requests, console messages and Puppeteer-backed automation.
agent-browser★ 51.8kVercel Labs' native Rust browser automation CLI for AI agents: accessibility-tree snapshots with element refs, a per-session CDP daemon, an MCP server and built-in agent skills.
UI-TARS Desktop★ 39.6kByteDance's multimodal agent stack and desktop app that controls a computer's graphical interface using vision-language models.
CloakBrowser★ 32.9kStealth Chromium build with source-level fingerprint patches that drops into Playwright or Puppeteer code, so agents and scrapers browse without tripping bot detection.
Cua★ 32.4kInfrastructure for computer-use agents, providing sandboxes and SDKs that let agents control full desktops on macOS, Linux, and Windows.
invisible_dots★ 51Self-hosted AI agents that each get a QEMU virtual machine of their own, with a desktop, a shell and a patched Firefox built not to look automated