Your AI team, in one local-first desktop workspace.
Bring your own accounts. Keep control of your data, tools, and computer.
OpenBot is a desktop app for a small team of persistent AI Bots, in a chat that feels like a team messenger. Each Bot runs on Claude Code, Codex, Cursor, OpenCode (including local models from Ollama or LM Studio), Gemini CLI, Grok Build or any other agent that speaks the Agent Client Protocol, with its own role, model, permissions and tools. A Chief of Staff takes your requests, does the work itself or hands it to the right Bot, and only comes back when there is a result or it needs you.
Behind every quick call — which model answers, whether a new Bot is worth creating, whether a message deserves a notification, whether a step is risky, what to click next on a screen — sits Jev, a fast typed-decision API. Bots can also use a virtual computer: a Linux desktop with a browser that you can watch live and take over at any time.
Your keys and logins stay on your machine. OpenBot has no hosted backend and ships no bundled credentials.
- Build a small AI team. Give each Bot a role, an engine and model, permissions, connected tools and, if it needs one, a computer. Each Bot has its own face, and its expression tells you whether it's thinking or waiting for you.
- Delegate through the Chief of Staff. It creates a new Bot only when an existing one can't do the job, hands tasks between Bots, and keeps progress chatter out of your way until there is something worth reading.
- Approve what matters, skip what doesn't. Reads and edits inside the shared workspace just happen. Anything with side effects outside it asks first, with Allow once, Always allow or Deny.
- Let Bots use a browser. With Docker Desktop, Bots drive Chromium on a shared Linux desktop, step by step, and you see every step in the chat.
- Automate on a schedule. Routines run a Bot's instructions every weekday at 8:00 or on an event, and rehearse as dry runs until you turn on live runs.
- Connect tools. Add MCP servers from a curated gallery or the community registry, then choose which Bots may use each one.
- Stay in the loop from your phone. Pair a phone with a QR code on your Wi-Fi, Tailscale or Cloudflare Tunnel; traffic is end-to-end encrypted.
Jev (by TypeSafe) answers typed questions — yes/no, one of N, a score — in a few hundred milliseconds, and every answer comes with a calibrated confidence. OpenBot never lets Jev write or run anything: it asks a question, reads the answer, and applies it with its own code and safety checks.
| Where | What Jev decides |
|---|---|
| Every message | Which engine and model answers (unless you pin one) |
| Chief of Staff | Handle it, delegate it, or create a new Bot — and whether that Bot is justified |
| Notifications | Whether a Bot's message is worth interrupting you, or waits for the daily digest |
| Risky steps | Whether an action is safe to take without asking you |
| Loops and routines | Whether a chain of Bots is going in circles; whether an event should start a run |
| Computer use | Which action comes next on the screen, and whether the goal is already done |
Confidence decides what happens next: 0.9 and above OpenBot acts on its own,
0.5–0.9 it asks for confirmation or takes the cautious path, below that it stops
and asks you. Without a Jev key nothing is guessed: Bots are only created when you ask,
risky steps always need your approval, and computer tasks stop with a clear reason.
Every decision is kept in the local decisions table, so you can see afterwards why
something happened.
Add your TypeSafe key in the setup wizard or in Settings → Jev, where you can also cap how many requests each kind of decision may make per minute.
With Docker Desktop running, OpenBot starts a Linux desktop in a container
(images/desktop: Xvfb, Chromium, and a noVNC live view). Each Bot with computer
access gets its own screen; the workspace folder is shared with the container. You can
watch any screen live and take over the mouse and keyboard at any time.
A Bot asks for a task in plain words (computer_task: "On wikipedia.org, search for
'Ada Lovelace' and open her article"). OpenBot then runs a fast loop in which Jev only
ever picks one described action:
flowchart LR
A["Read the page<br/>visible controls, open dialogs first"] --> B["Build options<br/>Type into “Search Wikipedia”<br/>Click link “Ada Lovelace”<br/>… Done · Needs you"]
B --> C["Jev picks one<br/>with a confidence"]
C --> D{"Safety check<br/>risky or sensitive?"}
D -- "ask" --> E["Approval card<br/>or take over"]
D -- "ok" --> F["Act inside the page<br/>click, type, key, scroll"]
F --> A
C -- "Done" --> G["Task complete"]
- Options are described, not numbered. Jev chooses between "Type into searchbox 'Search Wikipedia'" and "Click link 'Ada Lovelace'", never between element #12 and #40. Elements that mention the goal come first, and the list stays short.
- Common chores are handled in code. Cookie notices are closed ("Reject all" first) without asking Jev, and typing into a search box submits it.
- Clicks and keys go inside the page through the Chrome DevTools Protocol, so they land where they should wherever the window is.
- Unsure means stop, not guess. Below the confidence threshold the task stops and tells the Bot the likeliest options ("click link 'Ada Lovelace' 34%, …"), so it can steer the task, give it the text to type, or ask you. Logins, payments and 2FA hand the screen to you.
- A stop is double-checked. If a task stops short, Jev checks the final page against the goal once; if the goal is already met, the task counts as done.
In tests against live sites with a real Jev key, "search Wikipedia for Ada Lovelace and open her article" took 2 steps (about 2 seconds), and "search YouTube for a channel and open the first result" 3–4 steps (about 4 seconds).
Every step shows up in the chat as it happens. Bots are not a security boundary from each other — they share one workspace and one computer — and using your own machine instead of the container is opt-in and asks every time.
OpenBot is in active development. Download an installer from the
latest GitHub Release:
macOS DMGs are provided for Apple Silicon and Intel, Windows has an x64 installer,
and Linux has AppImage and .deb packages. Installers are not signed with a paid
developer certificate, so your operating system may show a security warning.
On macOS, drag OpenBot to Applications and open it once: macOS says it can't verify the
developer. Open System Settings > Privacy & Security, scroll to OpenBot and choose
Open Anyway (only the first time). If macOS says the app "is damaged" (0.1.15 and
earlier were not signed at all), run xattr -dr com.apple.quarantine /Applications/OpenBot.app
or install 0.1.16 or later.
Or build from source. You need Node.js 22.12 or newer and pnpm 10:
corepack enable
pnpm install
pnpm build
pnpm --filter @openbot/desktop startOn first launch, follow the setup wizard: add a TypeSafe (Jev) key and connect at least one engine (their CLI login works; an API key is optional for Claude Code and Codex). Docker Desktop is optional and enables the virtual computer. OpenBot keeps credentials in a local encrypted vault.
| Engine | Install and sign in | Notes |
|---|---|---|
| Claude Code | claude auth login |
Native driver |
| Codex | codex login |
Native driver |
| Cursor | Cursor CLI, cursor-agent login |
Your Cursor plan; runs from a private home, file writes fenced to the workspace |
| OpenCode | opencode.ai, opencode auth login (optional) |
Cloud providers, free models, and local models |
| Gemini CLI | gemini-cli, run gemini once |
ACP mode |
| Grok Build | x.ai/cli, grok login |
ACP mode |
| Your own | Settings > Engines > Your own ACP agents | Any command that starts an ACP agent (Goose, Qwen Code, Copilot CLI...) |
Local models. Install OpenCode and start Ollama or LM Studio: their models appear in a
Bot's model list (Settings > Engines shows what was found). OpenBot gives Ollama models a
32k context (it makes a copy of the model with a bigger num_ctx; the default 4096 tokens
cut the agent's instructions) and loads LM Studio models with the same context. Other
addresses: OLLAMA_HOST, OPENBOT_LMSTUDIO_URL; context size: OPENBOT_LOCAL_CONTEXT.
Small models (8-9B) handle short tool-using tasks; Jev routes heavier work elsewhere.
Engines are detected at start-up; after installing or signing in to one, press Check again in Settings > Engines (no restart needed).
![]() |
![]() |
| Light and dark themes follow your system, or pick one in Settings. | The same app on a paired phone. |
You can run the harness without the desktop shell and open its local UI in a browser:
pnpm --filter @openbot/server dev serveThen visit http://127.0.0.1:4577/app.
pnpm install
pnpm build
pnpm typecheck
pnpm test
pnpm lint
pnpm format:checkThe monorepo uses TypeScript, Electron, React, Fastify, SQLite, and pnpm workspaces. Unit and integration tests use fake engines, a fake computer and a fake Jev by default, so routine development does not need provider credentials. Playwright covers desktop and cross-package flows.
The screenshots in this README come from the UI's mock server with a demo scenario;
regenerate them after UI changes with node scripts/readme-screenshots.mjs (after
pnpm build).
For how it works inside (processes, a chat turn, safety gates, computer use, storage, Client API), see docs/architecture.md. See CONTRIBUTING.md for pull request guidance and the optional AI-assisted workflow included with the repository.
The desktop app, chat, team, approvals, routines, connectors and computer use work end to end and are covered by automated tests; computer use has also been tested against live sites with a real Jev key. OpenBot is still an early preview: real provider and remote-access combinations continue to get manual testing. See the open issues for current gaps.









