Godmode Bot

The AI coworker that works like a human on your computer.

Godmode Bot gives Claude a real browser, your logins and your 2FA codes — safely — so it can finish tasks
end-to-end without interrupting you. Start with one chat, or build a team of persistent agents with their own
memory, routines and history.

Get Godmode ·
Quick start ·
Features ·
Security ·
Architecture

_{Godmode logs into a portal: the password and the 2FA code are filled from the vault — the AI never sees them. The live browser preview on the right shows where it is; Take control jumps in anytime.}

✨ Why Godmode?

Most AI assistants stop the moment they hit a login screen. Godmode Bot is built around the things a real coworker
needs to be useful:

• Access — a managed browser (via browser-use), your Chrome sessions,
  and hundreds of apps through Composio or any MCP server.
• Credentials without exposure — a local, encrypted vault for logins and TOTP 2FA. Passwords and codes are typed
  into the page for the agent; the model never sees them.
• Autonomy — powered by Claude Code (Opus 5.5) in full-bypass mode, so work continues
  without permission prompts.
• Continuity — every agent has its own git repository with memory, conversations, logs and state.
• Judgement — when a login is missing or broken, agents tell you exactly what they need instead of stalling.

🚀 Features

_{Phone app — what your agents are doing right now, a chat that streams as it's written, the agent's browser live (tap to take control), and the answer.}

Chat first — hand over a task, pick up where you left off	Agents — persistent coworkers with memory, schedules and tools
Task board — tickets for your agents; Todo starts them, coding tickets end in a pull request	Task detail — live progress, branch, pull request and follow-ups
Agent detail — runs, routines, memory (git), history, settings	New agent — describe it in plain words or start from a template
Routines — everything your agents do on a schedule, at a glance	Working folders — point a chat or an agent at any folder on your machine
Slash commands — every Claude Code command, right in the composer	Browser — live view of the agent's Chromium, take over anytime
Logins — encrypted, scoped per workspace, filled for agents	2FA codes — import Google Authenticator QR screenshots
Password import — Chrome, 1Password, Bitwarden, Apple Passwords and more	Import review — new, updated and already saved logins at a glance
Integrations — custom MCP servers and Composio toolkits, scoped per workspace	Inbox — agents report missing or broken logins
Activity — every run, its cost, duration and result	Security — fill-only secrets, device keychain and auto-lock
Workspace folders & repos — every agent in the workspace works with them	Add a repository — paste a URL, Godmode clones it and keeps it up to date
Connect a phone — scan a one-time code; the phone gets its own key	Phone settings — Tailscale status, paired phones, remove one anytime
Claude Code & MCP — connected apps, their access and the tools they can call	One click — Godmode adds itself to Claude Code; ask for an agent in your next session
Messaging — talk to agents from Slack, Telegram and Microsoft Teams	Bot settings — approve people, pick agents, see every chat
Own tab per chat — the preview shows only this chat's page, while others browse alongside	Parallel chats — one browser profile, one tab per chat; switch between them live
Follow-ups — the agent sets itself a time to continue; move it, cancel it or continue now	Back on it — at that time the agent picks the chat up again, with all the context
My tasks — everything your agents need from you on one board: things to do, questions, approvals, open decisions	Open decisions — an agent that finishes with a question for you gets a ticket; your answer continues its chat
Heartbeat — the agent wakes on its own rhythm to move its tickets forward and run its checklist	Beats & watchdog — every beat leaves a trail; stalled or looping runs are stopped with a precise report
Dreaming — agents keep their memory short enough to load into every chat; every dream is a diff you can undo	Your rules — when agents dream, with which model, and how long their memory may get
Pause & continue — the agent finishes its step, stands still and picks the work up where it stopped	Usage limit — the work waits for the reset and continues by itself, with what you wrote meanwhile
Bot check — what bot detection sees in the agents' browser	Without hardening — headless Chrome gives itself away
Tools — APIs agents use with your keys, scoped globally, per workspace or per agent	Add a tool — presets bring the address and docs, you add the key
SSH servers — password or key, sealed in the vault; host keys pinned on the first connection	Work on servers — pick servers for a chat; the agent runs commands and edits files there
Plugins — what each one brings, what it can reach, whose runs load it, and an update one click away	Featured — Claude Video and oh-my-claudecode from GitHub in one click, guardrails made by Godmode below
Version and updates — the commit that runs, what changed upstream, update or uninstall	Contents — the skills, subagents, commands, hooks and servers a plugin brings
Install from GitHub — any Claude Code plugin by owner/repo or link	In the chat — plugins refuse steps, mask secrets and post notes while the agent works
Read and edit the code — a small plugin Godmode drafted waits for your review; Claude Code's validator checks every change	Options — set what a plugin protects or refuses without touching its code
Cleanup — what the data folder holds, and a self check of everything Godmode relies on	Free up space — safe items are picked for you; whatever may still hold work stays

📦 Install

Godmode is open source under the MIT License. Two ways to run it:

• Build it yourself — free. Clone this repo and run it from source or build your own app
  (Build from source). Every feature, no licence key, no limits.
• Godmode Pro — the official app. Signed, ready-to-install apps for macOS, Windows and Linux, automatic updates,
  the install script and Docker image, and support from the people who build it. Start a 14-day free trial at
  usegodmode.com ($39/month, or $29/month billed yearly). Pro pays for Godmode's
  development.

Desktop app

Start the free trial at usegodmode.com and download the app from your welcome page — or
later from usegodmode.com/download with your license key:

• macOS — .dmg (Apple Silicon & Intel)
• Windows — .msi / .exe
• Linux — .AppImage / .deb / .rpm

The app keeps itself up to date: new versions download in the background (from usegodmode.com/api/update,
which mirrors the signed bundles of the latest release), and a Restart button appears in the sidebar once one is
ready.

On first launch the onboarding checks your system and installs what's missing with one click:

Headless server + web dashboard

Run Godmode on a home server, NAS, VM or Raspberry Pi and connect from any browser:

curl -fsSL https://usegodmode.com/install.sh | GODMODE_LICENSE=GM-XXXXX-XXXXX-XXXXX-XXXXX sh
godmode serve --host 0.0.0.0     # prints the dashboard URL
godmode token                    # access token for the first login
godmode password 'a-strong-password'

Or with Docker:

docker compose up -d   # dashboard on http://localhost:7777

Put the dashboard behind TLS (Caddy, Traefik, Tailscale…) when you expose it beyond your machine.

Build from source

git clone https://github.com/codextde/godmode-bot && cd godmode-bot
pnpm install
pnpm dev          # core + web UI on http://localhost:1420
pnpm build:app    # or build your own desktop app (apps/desktop/src-tauri/target/release/bundle)
pnpm build        # or a standalone server binary (packages/core/bin/godmode)
docker build -t godmode-bot .   # or your own Docker image

Needs Node 22+, pnpm, Bun and, for the desktop app,
Rust. Builds of your own never ask for a licence key.

Phone app (iOS and Android)

1. Install Tailscale on the computer that runs Godmode and on your phone, and sign in
   with the same account.
2. In Godmode open Settings → Phone → Connect a phone.
3. Open the Godmode app and tap Scan QR code (or point the camera app at the code).

The code works once and for five minutes; the phone gets its own key, and you can remove it anytime in the same place.
Godmode only listens for phones on the computer's Tailscale address. Without Tailscale, link the computer to a
Godmode Cloud with phone access on: the phone then also reaches it through the cloud's gateway.
The app lives in apps/mobile (Expo) — build it with bun run ios / bun run android or EAS until
it's in the stores.

Godmode Cloud (optional)

Open a computer's dashboard from any browser and reach it from your phone without Tailscale: deploy
apps/cloud (Coolify or Docker Compose; the only setting is its address), then link Godmode in
Settings → Cloud. The computer keeps one outbound connection to the cloud; there is no port to open. The cloud
relays, and can see, everything done through it, so link only to a cloud you trust.

Runners — another Mac that works while yours sleeps

1. In Godmode open Runners → Add runner and copy the command.
2. Run it in Terminal on the other Mac (a Mac mini, a laptop that stays plugged in — on the same network or in your
   Tailscale). It installs Godmode as a runner that starts whenever you log in there, installs Claude Code and a
   browser, and pairs itself with your Godmode.
3. Start a chat and pick the runner under Run on in the message box.

The runner keeps its Mac awake while it serves. Sign in to Claude Code on it once (claude), and grant Accessibility
and Screen Recording on its screen if agents should use apps there — the runner's health view says what's left. On the
runner: godmode runner status, godmode runner pair (a new pairing code to paste under Add runner → Enter a
pairing code), godmode runner uninstall.

Claude Code & other AI tools — set Godmode up from your terminal

1. In Godmode open Settings → Claude Code & MCP → Connect Claude Code. Godmode adds itself to Claude Code on this
   computer as an MCP server, for every project.
2. Start a new Claude Code session and ask: “Create a Godmode agent that checks our competitors' pricing every Monday
   morning and sends me a summary.” The agent, its instructions and its schedule show up in Godmode.

Connect another app gives any other MCP client (Cursor, Codex, Claude Desktop…) its own key, with the config to
paste. A key either sets up and steers (agents, automations, tasks, VMs) or only looks; remove an app in the same place
and its key stops working. The same tools work from a shell, for scripts:

export GODMODE_CONNECT_TOKEN=gmc_…          # the key from Settings → Claude Code & MCP
godmode tools                                # what the key can do; `godmode tools agent_create` shows the arguments
godmode call agent_create '{"name":"Scout","role":"Research analyst","instructions":"…"}'
godmode mcp                                  # the MCP server itself (stdio) — what the apps start

godmode here is the core binary (in the desktop app: Godmode Bot.app/Contents/MacOS/godmode-core; the dialog shows
the full path). Inside Godmode nothing changes: the built-in Godmode agent creates and manages agents from any chat.

⚡ Quick start

1. Onboarding — pick a vault passphrase (enable Remember on this device so routines run unattended).
2. Add access — import your Chrome sessions, import or add logins in Vault → Logins, and import 2FA QR codes in
   Vault → 2FA Codes (Google Authenticator → Transfer accounts → Export → screenshot).
3. Chat — ask Godmode anything: “Log into our billing portal and download September's invoice.”
4. Create agents — “Create an agent that checks our competitors' pricing every Monday and sends me a summary.”
   Godmode creates the agent, its instructions and its automation.
5. Automate — “When I get an email with an invoice, save the PDF to Drive and log it in my sheet.” Godmode picks the
   trigger (here: a new Gmail message via Composio), the agent and the steps, and it runs whenever it happens.
6. Check the inbox — if an agent couldn't log in, it tells you what's missing.

Computer use — share a window or your screen

Click Share (the screen icon) in the message box and pick what the agent may see and control in this chat:

The chat shows a live view of what's shared; Take control lets you click and type into it yourself (a window keeps
running in the background). Stop sharing takes effect immediately, even mid-run. Agents can also get unattended
desktop access for routines (agent settings → Computer). Setup lives in Settings → Computer:

• macOS asks once for Accessibility and Screen Recording for Godmode (restart Godmode after granting).
• Cua Driver (cua-driver from PyPI, MIT) is downloaded via uv the first time an agent needs it (or with one
  click), and kept at the version Godmode was tested with. Without it, Godmode's built-in macOS helper controls
  windows on its own.
• Windows / Linux: single windows need Cua Driver; the whole desktop uses a built-in PowerShell helper (Windows) or
  xrandr + ImageMagick + xdotool (Linux/X11), and falls back to Cua Driver's primary display.

Virtual machines — give an agent its own Mac

Open Virtual machines in the sidebar and click New VM (first time: Set up downloads Godmode's own copy of
Tart — no Homebrew needed). Pick an image — macOS Tahoe is a ~27 GB download once (in parallel,
resumable; Settings → Virtual machines lists downloaded images); every further VM from it is ready in seconds — and
assign the VM to an agent (agent settings → Virtual machine), a chat
(the VM chip in the message box) or a workspace. A run works in its chat's VM, else its agent's, else its
workspace's, and boots it when needed. You can also just ask Godmode: "Give the iOS agent its own Mac."

Needs a Mac with Apple silicon. macOS allows two macOS VMs to run at the same time; Godmode tells you which one to
stop when a third is needed.

SSH servers — let agents work on your servers

Open SSH servers in the sidebar and click Add server: host, port, user and either a password or an SSH
key — paste it, load a file, pick one from ~/.ssh on this computer, or generate a new one and add its public key
to the server's ~/.ssh/authorized_keys. Test connection signs in once and shows the server's host key; Godmode
trusts only that key from then on. Then pick the server for a chat (the SSH chip in the message box) or an
agent (agent settings → SSH servers, used in every run). A run gets its chat's servers and its agent's.

Plugins — give your agents new skills and guardrails

Open Plugins in the sidebar. Featured has whole Claude Code plugins that install from GitHub in one click:

Add plugin → Install from GitHub takes any other plugin by owner/repo, a GitHub link (also to a folder or a
branch) or a clone URL. Godmode downloads it at a fixed commit, checks it with Claude Code and shows what it brings:
its skills, subagents, commands, hooks and MCP servers, and the tokens it adds to every session. Every plugin has a
switch, and Runs for decides whose runs load it: every agent or the ones you pick. Godmode looks for newer
commits every few hours; Update installs one (the old version stays if Claude Code refuses the new one), and
Uninstall removes the plugin with its files. You can also ask Godmode in a chat to install a plugin: it arrives
switched off for you to look at.

Made by Godmode has small plugins that run inside every turn — add one and it is on for every agent:

Each has options (the paths, the patterns, the limit). For anything else, Write one from scratch opens an
editor with a starting point, or Ask Godmode to write one and review its draft: a plugin an agent wrote arrives
switched off, and switching it on is your OK — for exactly the code you read.

A plugin is real code that works with the agent's access, so Godmode shows what it is before it runs: Claude Code's
validator checks every change, and the plugin's page lists what it hooks into and what it can reach outside the
conversation (files, programs, the network; for a plugin from GitHub the commands its hooks run and the servers it
starts). A plugin that doesn't pass can't be switched on; one that stops passing after a Claude Code update is left
out of runs and the chat says so. What a small plugin posts ($.ui.log, a toast, a status) shows in the chat as a
note from it.

Good to know

• macOS — Chrome session import reads your Chrome profile, which macOS protects: grant Godmode
  Full Disk Access (System Settings → Privacy & Security) and retry. Nothing is uploaded — cookies go straight
  into Godmode's own browser profile.
• browser-use content extraction (browser_extract_content) needs an OpenAI API key (Settings → Integrations →
  API keys). Without one, Godmode hides that tool and agents read pages via page state and screenshots instead.
• Unsigned builds: until code signing is configured for releases, macOS may ask you to confirm opening the app
  (right-click → Open) and Windows SmartScreen may warn on first launch.
• Claude Code sign-in: agents use your Claude Code login (claude → /login) or an Anthropic API key stored
  in the vault.

🧠 How it works

┌──────────── Godmode desktop app (Tauri 2) / web dashboard ────────────┐
│  React 19 · Tailwind v4 · shadcn/ui · aicss components                 │
└───────────────┬────────────────────────────────────────────────────────┘
                │ HTTP + WebSocket (token / session)
┌───────────────▼────────────────────────────────────────────────────────┐
│  godmode core (Bun)                                                    │
│  runner · vault · scheduler · agents (git) · MCP gateway · browser ·  │
│  computer use (Cua Driver · native helper)                             │
└───────┬──────────────────────────────┬─────────────────────────────────┘
        │ spawns per turn               │ launches + CDP
┌───────▼──────────────────────┐   ┌────▼─────────────┐
│ claude -p (Opus 5.5, bypass) │   │ managed Chromium │◄── browser-use MCP
│  MCP: godmode · browser ·    │   └──────────────────┘
│   computer · composio · …    │
└──────────────────────────────┘

• Each turn runs claude -p --output-format stream-json inside the agent's git repository and streams every
  thought, tool call and screenshot to the UI in real time.
• The Godmode MCP gateway gives agents vault tools (vault_fill_login, vault_fill_totp, …), delegation
  (agent_delegate), management tools for the main agent (agents, automations, the task board), and
  report_missing_login.
• Tasks: a ticket in Todo starts its agent in the ticket's own conversation. Coding tickets work in a checkout of
  one of the workspace's repositories on their own branch; Godmode pushes it with your git login and opens the pull request
  with the GitHub CLI (gh) — or links to the page that opens one.
• Details: docs/ARCHITECTURE.md.

Agent repositories

~/.godmode/agents/invoice-collector/
├── CLAUDE.md                 # identity & instructions (generated)
├── MEMORY.md                 # long-term memory the agent maintains
├── memory/                   # notes
├── conversations/<id>.md     # transcripts
├── runs/2026-09-27/<id>.jsonl# raw event logs (secrets redacted)
├── state/agent.json          # config snapshot
└── workspace/                # files the agent produced

Every run is committed, so you can see exactly what an agent learned and did — and roll back.

🔒 Security

• Envelope encryption: scrypt (N=2^17) → key-encryption key → random 256-bit data key → AES-256-GCM per secret,
  bound to its database row.

• Fill, don't reveal (default): agents ask Godmode to type a password/2FA code into the page via CDP; the value
  never enters the model's context. Reveal mode is opt-in per agent and audited.

• Site-bound fills: a login is only ever typed into its own website (https, real password fields) — a phishing or
  prompt-injected lookalike page gets nothing.

• Address-bound API keys: a tool's key is added by Godmode and only sent to URLs under the tool's address (redirects
  elsewhere aren't followed); moving a saved key to another address or into agents' environment needs your passphrase.

• Re-auth for sensitive actions: revealing a password or granting an agent reveal access needs your vault passphrase.

• Redaction of known secrets in transcripts, logs and the UI · audit log of every secret access.

• Local-first: API on 127.0.0.1, per-run MCP tokens, DNS-rebinding & CSRF protection, strict CSP,
  rate-limited logins, HttpOnly/SameSite cookies for the dashboard. Nothing leaves your computer unless you link it to
  a cloud.

• Godmode Cloud is opt-in per computer: a linked computer dials out to the cloud, which relays browsers and
  phones to it. The cloud terminates HTTPS, so it can see what passes through. The admin area has no way to open
  someone else's computer. Whoever operates the cloud (server, database, sign-in e-mail) is trusted and technically
  can. The computer decides what the cloud may do: browser access, phone access, and whether the vault and saved
  passwords may be used through it (off by default). Some actions are never possible through the cloud.

• Remember this device keeps the data key in the OS keychain so routines run unattended — disable it to require
  your passphrase after every restart.

• Phones pair with a one-time, five-minute QR code and get their own key (stored hashed on the computer, in the
  Keychain / Keystore on the phone). Their key only works on the computer's Tailscale address (and through the gateway
  of a cloud the computer is linked to), is only sent to an address that proves it's your Godmode, and opens a fixed
  set of routes: no logins, 2FA codes, backups, integrations, settings or folders, and only screens shared in a chat
  can be controlled. A paired phone can still ask agents to act on your computer — remove a lost phone in
  Settings → Phone, and turn on Require Face ID in the app.

• Connected apps (Claude Code, other MCP clients) get a key of their own (stored hashed) that opens only the
  management tools of the MCP gateway: no passwords, 2FA codes, settings or files. They see which logins exist (names
  and usernames) and what agents were asked and answered. They act as the built-in agent and inside its limits — an
  agent they create can use saved logins but not read them, can't manage agents and can't control this computer until
  you allow it. Every change and every refused call is in the audit log; removing an app cuts it off at once. A key
  that sets up and steers can still create agents and automations that act with your logins: connect only apps you
  trust, and give the others a look-only key.

• Runners pair with a one-time code and pin each other's keys; the link is end-to-end encrypted (X25519, AES-256-GCM)
  and the runner's API never listens beyond its own loopback. A paired Godmode gets your vault key on the runner so
  logins work there — pair only computers you control.

⚠️ Agents run Claude Code with bypass permissions by default. Treat them like a trusted coworker with access to
your machine; for sensitive work give the agent its own macOS VM (see above), or run Godmode in a VM or
container. See SECURITY.md.

🛠️ Development

pnpm install
pnpm dev          # core (bun --watch, :7777) + UI (vite, :1420)
pnpm dev:app      # full desktop app (tauri dev)
pnpm typecheck && pnpm test
pnpm build:app    # desktop bundles

Monorepo: packages/shared (types) · packages/core (daemon) · apps/desktop (UI + Tauri) · apps/mobile (phone
app, Expo — its own toolchain, see apps/mobile/README.md) · apps/cloud (Godmode Cloud,
Next.js, see apps/cloud/README.md).
See CONTRIBUTING.md.

🗺️ Roadmap

• Chat, persistent agents, routines, delegation, subagents
• Vault (logins with Chrome / 1Password import + TOTP with QR import), Chrome session import, missing-login inbox
• Composio + custom MCP servers, workspaces, voice mode, backup/restore
• Desktop app (macOS/Windows/Linux) + headless web dashboard
• Working folders, Claude Code slash commands, live browser preview in chat, desktop auto-update
• Computer use: share a window (background control via Cua Driver), a display, every monitor or a browser tab
• Automations: schedules, app events (Composio triggers), plain-language conditions and webhooks
• Heartbeats: agents wake on their own rhythm to move their tickets forward and run a checklist; a watchdog stops stalled and looping runs
• Agents working in a dedicated macOS VM (Tart / Virtualization.framework): shell, files and screen, assigned per agent, chat or workspace
• API tools: any API with a key (Nano Banana, OpenAI, ElevenLabs…) for agents, global / workspace / agent
• SSH servers: agents run commands, edit files and copy files on remote machines — password or key, sudo, pinned host keys
• Plugins: Claude Code plugins for agents — one-click installs from GitHub (Claude Video, oh-my-claudecode), updates and uninstall, a gallery of guardrails, options, an editor, drafts written by Godmode, checked before they run
• Windows / Linux VMs
• Phone app (iOS / Android): chats, runs, automations, live browser, screen and VM views, paired over Tailscale
• Runners: another Mac does the work of a chat while this one sleeps — one install command, encrypted link, setup copied, live view
• Runners on Windows and Linux, tasks of the board on a runner, VMs copied to a runner
• Godmode Cloud (optional, self-hosted): your computer in any browser, phones without Tailscale, accounts and plans
• Claude Code & MCP: Claude Code and other AI tools create and manage agents, automations and tasks from outside, plus a godmode command line for scripts
• Push notifications
• Team mode: shared workspaces and approvals

🙏 Credits

Claude Code · browser-use · Cua ·
Composio · Model Context Protocol ·
Tauri · shadcn/ui · aicss ·
claude-mem · Tart · Bun

📄 License

MIT © 2026 Codext GmbH. Use it, change it, ship it. The official Godmode Pro builds and subscription at
usegodmode.com follow the Terms.