# 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

- Category: Agents & Automation / Computer & Browser Use
- Language: TypeScript, Python, Go
- Licence: MIT
- Repository: https://github.com/feder-cr/invisible_dots
- Canonical page: https://ai-tldr.dev/tools/feder-dots/
- Updated: 2026-10-07

## In short

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.

## Overview

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.

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

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

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

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

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

```bash
node apps/cli/dist/invisible-dots.mjs server
```

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

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

## 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

## Version history

- 2026-10-07: 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.
