Dot

Dot is an always-on autonomous agent for macOS. Give it a goal in plain words and it works on it until it is done, with what a person at this Mac would use: a shell and the file system, the web, its own Chrome profile (browser use), the screen, mouse and keyboard (computer use), AppleScript, a memory that lasts between runs, schedules, MCP tool servers and sub-agents.

It runs on models from Ollama (local models, and cloud models through the local Ollama server), the OpenAI API, OpenCode Go, the Anthropic API (the Claude models), OpenRouter (the models of many labs on one key) or OpenCode Zen's free models. A daemon on the Mac serves a web UI and a REST API and runs the schedules, and dotx run and dotx chat work in the terminal. Dot runs on macOS only.

Dot works on a goal on its own, and by default it asks you before a risky step. In the default approval mode, ask, edits and routine work run without a question, and what the policy raises waits for your answer on a card in the chat. It stops for what it must not decide alone (money, credentials, public posts, messages sent for you, privilege, system settings), everything it does is recorded, and it can be stopped at once. In yolo nobody is asked, but money, credentials, your secrets, messages and posts in your name still wait for you: see Autonomy. Read Safety before you let it work on a machine that holds data you care about.

With the default models, what a run reads leaves this Mac. They are cloud models of Ollama: the Ollama server on this Mac passes each call on to Ollama's servers, with the goal, the messages, the text of the files and pages the run read, what its commands printed and its screenshots. To keep a run's conversation on this Mac, choose a local model for each role in Settings › Models: the default model, and the fast, review and vision models. What leaves this Mac lists everything that goes out.

The pictures show a run of Dot's scripted test model, under the name of a real one.

Requirements

• macOS 15.2 or later (developed and tested on macOS 26, Apple silicon)
• Python 3.13 and uv
• ripgrep: brew install ripgrep
• Google Chrome, which the browser tools drive through Playwright
• Xcode's Command Line Tools (xcode-select --install), with which the service builds the small app that runs Dot
• The models of one provider at least:
  • Ollama, running. Cloud models (their tag is cloud or ends in -cloud) need ollama signin once. Searching the memory by meaning needs an embedding model: ollama pull bge-m3
  • an API key for OpenAI, OpenCode Go, Anthropic or OpenRouter
  • OpenCode, for Zen's free models (no key)

Install

1. Install the tools Dot uses: brew install uv ripgrep, Google Chrome, and Xcode's Command Line Tools (xcode-select --install).
2. Get Dot: git clone https://github.com/senoldogann/Dot.git, then cd Dot.
3. Install its packages: uv sync.
4. Set it up: uv run dotx setup.
5. Open it: uv run dotx open opens the web UI in your browser, signed in.
6. If you want Dot in a window of its own, with a menu bar item and ⌘⇧Space: download Dot_<version>_universal.dmg from the latest release, open it and drag Dot to Applications. The app is signed and notarized, and keeps itself up to date (see the desktop shell).

dotx setup does the following, then installs the service and gives the address of the web UI:

• It checks this Mac: the macOS version, ripgrep, Chrome and Xcode's Command Line Tools.
• It asks which provider's models Dot runs on, and stores the provider's API key in Dot's .env file (mode 0600) when it needs one.
• It offers the provider's models that can call tools. The one you pick becomes the model new chats start on, and the model of Dot's own work: the fast and review models, and the vision model when it sees images.

Without a terminal, flags give each answer: --model provider:model, --key-stdin (the key on standard input) and --no-service (the service is left as it is).

The web UI says the same on its home. While the default model cannot answer, a Set up a model card says why: no key, a refused key, or a provider that is out of reach or does not offer the model. It leads to Settings › Models, Settings › Providers or dotx setup.

First steps

Type a goal on the web UI's home, or give one in a terminal:

uv run dotx run "Find the opening hours of the Helsinki Central Library and save them to hours.md"
uv run dotx chat

The command line has the rest: dotx doctor, which checks the whole setup and says how to fix what is missing, and the flags of run and chat.

Dot on the phone

The web UI works on a phone too, as an app on its home screen that notifies you. The phone reaches the Mac through your own network: with Tailscale on both, tailscale serve --bg 8765 on the Mac and the Mac's name on the tailnet in Dot's config file. Dot on the phone has the steps.

Safety in short

• Who answers the policy's questions. Most actions need no answer. For those that do, ask (the default) puts the question to you, auto lets a review model answer, and yolo lets the run go on alone. In every mode, yolo too, money and credentials are handed to you and a message or a post in your name needs a yes (the review model's in auto), whatever your rules say; a yolo run also asks you before it reads your secrets. See Autonomy.
• What leaves this Mac. There is no telemetry; the desktop app asks GitHub for its latest version and, on your yes, downloads it from there. The models get the run's conversation, and the sites, search engines and services a run uses get what it sends them. See What leaves this Mac.
• The daemon listens on this Mac's loopback address alone. Its API needs its token, except for a health check, the daemon's proof that it holds the token, and the pairing of a phone. A phone comes in through your own tailnet.
• A vulnerability is reported privately, as SECURITY.md says.

Integrations

integrations/ carries ready-made additions. REA (Reverse Engineer Anything) adds its MCP server and workflow skill: a run can inspect a shipped app or binary and explain how a feature works, with the evidence and its limits. replica-skill adds eleven skills that turn an app into a recon map, a rebuild, a bug hunt and a launch (MIT, by Jake Schincariol).

Documentation

• The command line: dotx doctor, run, chat and their flags
• Models and providers
• Runs and tools: how a run works, its tools, delegation
• Autonomy: approvals, goal mode and the end of a run
• The harness: what Dot improves around its model, and how a change is adopted
• Safety and privacy: what leaves this Mac, the policy, the sandbox
• The daemon, the web UI and the desktop shell
• Dot on the phone
• Browser and computer use
• Memory and schedules
• Agents and campaigns
• Apps, MCP servers, skills and plugins
• Configuration
• Development: the tests, the gate, measuring the agent
• Status and known limits

CONTRIBUTING.md says how to propose a change, and CHANGELOG.md what changed.

License and security

Dot is released under the MIT License (LICENSE). The parts it carries from others keep their own licences, each beside them: the Inter and Geist Mono fonts (SIL Open Font License, static/fonts), the icons, which are Lucide's (ISC, and MIT for those Lucide took from Feather, static/js/LICENSE-Lucide.txt), the providers' marks (static/icons/providers/LICENSE), the parts of the appearance settings ported from an MIT-licensed project (static/js/appearance/LICENSE) and the character, a port of bloub (MIT, static/js/character/LICENSE).

Report a security problem privately, as SECURITY.md says, not in a public issue. Dependabot raises alerts and fixes for dependencies with a known vulnerability, and each week one pull request per kind of dependency that brings it up to date (.github/dependabot.yml: Python, the desktop app's npm and Cargo packages, the CI's actions); the weekly audit of the CI (audit.yml, item 217) stays.