Docs.

Install, launch, and find your way around.

Download

Head to clauge.in and hit the download button — Clauge auto-detects your platform and architecture and serves the right binary. Native builds are available for:

• macOS — Apple Silicon and Intel (.dmg)
• Linux — x64 and ARM64 (.deb, .rpm, or .AppImage)
• Windows — x64 and ARM64 (.exe installer)

First launch

On first launch you'll see a sign-in screen with three options:

• Continue with Google — enables cloud sync and Clauge AI credits if you subscribe later
• Continue with GitHub — same as above, plus pre-authenticates the GitHub CLI for Workspace issue sync
• Skip for now — start using Clauge fully offline; you can sign in later from Settings → Account

After that, Clauge opens to the Agent mode. You'll see the left rail (mode switcher), the sidebar (per-mode sessions / profiles / connections), the workspace, and the AI panel on the right. The bottom status bar shows the active mode, token usage, and the MCP server endpoint.

Switching modes

Every mode has a keyboard shortcut. Use ⌘1–⌘8 on macOS (or Ctrl+1–Ctrl+8 on Windows / Linux) to jump straight to any mode:

You can also click any icon in the left rail. Clauge remembers your last-used mode and restores it on next launch.

Two layers of AI: mode assistants and Workspace coworkers.

Clauge has two distinct AI surfaces, configured separately:

Mode AI assistance

Powers the REST batch runner, SQL NL→SQL, NoSQL queries, SSH command generation, and Explorer scan. Two options for billing — pick one or mix:

• BYOK — open Settings → AI Assistance and drop in your own Anthropic, OpenAI, Google, or OpenCode key. Keys go straight to your OS keychain; Clauge talks directly to the provider, no proxy.
• Clauge AI credits — subscribe and Clauge bills a single pool of credits you can spend across every provider and every mode. No separate keys to manage. Toggle in Settings → AI Providers.

Workspace coworkers

Coworkers are a separate concept. When you create a coworker in Workspace Mode → Coworkers, you pick which agent CLI it runs on top of — not a BYOK key or a credits pool. Available agents:

• Claude Code
• OpenCode
• Gemini
• Codex

The chosen agent handles authentication its own way (its own subscription, its own key, its own login). When a coworker claims a card or you @-mention them, that agent CLI spins up with the persona's prompt and starts working.

Spawn coding agents in parallel, each pinned to a purpose.

Supported CLIs

Claude Code, Codex, Gemini, and OpenCode run as terminal-based sessions inside Clauge. You can launch any combination side-by-side; each session is fully isolated — its own model, its own context, its own git worktree.

Creating a session

1. Click + New Session in the sidebar.
2. Pick a purpose (Brainstorming, Development, Code Review, PR Review, Debugging, or Custom).
3. Optionally override the git identity — commit as a coworker, not yourself.
4. Toggle Skip permissions for fully-autonomous runs when you trust the prompt.
5. Inject pinned files / folders / MCP servers from the Context Manager.
6. Optionally load extra tools from the Plugin Manager.

Purposes

Every session has a purpose that shapes the agent's focus from the first message. No more prompting it to "act like a code reviewer" mid-conversation.

Resume across restarts

Sessions survive app restarts and crashes. Clauge persists every prompt, response, and tool call so you pick up exactly where you left off — tabs, scroll position, pending queued prompts.

Usage analytics

Every session emits tokens-in / tokens-out, cost, cache-hit rate, and model mix. Aggregate views show the same per-day and per-purpose. Settings → Usage.

Every open tab on one spatial canvas.

What it is

Atlas is a free-form pan/zoom workspace where every open tab becomes a draggable, resizable window — Agent sessions, SSH terminals, REST requests, SQL and NoSQL editors, Explorer file browsers, and Atlas-spawned shells. Use it when you want to see multiple things at once instead of alt-tabbing between them.

Enable it

Atlas ships opt-in. Open it from the left rail; the first time you do, you'll see an intro card with a link to Settings → Atlas → Enable Atlas mode. Flip the toggle and the canvas activates.

State across modes

Tiles are reparented, not recreated, when you switch into and out of Atlas. CodeMirror undo, the cursor, the scroll position, terminal scrollback, and any open connections all survive the round-trip — keep typing in a SQL editor on Atlas, switch back to SQL mode, and you're still at the same character.

In-tile control surfaces

Tiles aren't read-only previews. Each kind ships with the editing affordances it needs:

• SQL — Run button, results table (the same one home SQL uses), connection / database picker.
• NoSQL — connection picker; for Mongo, a database + collection picker.
• REST — method picker, URL bar, the full headers / auth / params / body / pre-script editor, environment picker, and Send.
• Agent / SSH / shell — the full live terminal, with WebGL when available.
• Explorer — the full file browser scoped to the tab's connection.

Snap, zoom, and layouts

Tiles snap to the edges of neighbouring tiles while you drag; pinch / Ctrl+scroll to zoom; right-click drag or middle-click drag to pan. Tile positions and the viewport are persisted per workspace, so each project keeps its own canvas memory.

Spawn shells

The toolbar's terminal button drops a fresh shell onto the canvas, scoped to the workspace. Atlas shells live in the canvas — they don't appear as tabs in the home Agent or SSH lists.

Double-click to jump home

Double-click a tile's title bar to switch into the tile's source mode and focus the matching tab — a shortcut for "see the full panel" without leaving the keyboard.

Boards, notes, and AI coworkers — all driveable from outside via MCP.

Create a workspace

1. Open the Workspace mode from the left rail.
2. Click + New Workspace and give it a name.
3. Optionally link it to a local git repo — Clauge will scan for subprojects and auto-spawn one board per subproject.

Boards

Five default columns: Backlog → Todo → In Progress → In Review → Done. Review is a safety gate — it's not a column you skip past. Cards carry priority, tags, comments, review checklists, and links to the PR + agent sessions that touched them.

GitHub / GitLab sync

Clauge talks to GitHub and GitLab through the gh and glab CLIs. Install whichever one matches your remote, authenticate via the CLI, and the board's Sync button will pull open issues in and push finished cards back as pull requests.

Notes

A Notion-style WYSIWYG markdown editor. Per-project, linked to sessions, full-text searchable across every board, and exposed through MCP so external agents can read and edit them.

Coworkers

Named AI personas with their own prompts and providers — e.g. @alex the Brainstormer, @matt the Developer, @kim the Reviewer. Create them once in Settings → Coworkers; then any coworker can claim a card, comment, request changes, commit, and raise a PR.

Single-owner card lock

At any moment, exactly one entity owns a card — either a coworker or a terminal session. Switching owners, claiming from a terminal session, or chatting in the card drawer all flow through the same lock. No race conditions, no lost work.

Inbox

Mentions, review requests, and approval queues from every board collapse into the pinned Inbox in the side panel. Click to jump to the source card.

An HTTP client your AI — and any external agent — can drive.

Collections + environments

Group related requests into collections — set per-collection auth and pre-script hooks. Use environments for variables that change between staging / prod / local; overrides resolve clearly. Import existing Postman v2 / v2.1 collections or paste a cURL command directly.

AI batch runner

Open any collection and ask the AI: "run the smoke tests in staging". Clauge fires the whole collection, tracks pass / fail, and surfaces the failing request inline so you can re-run it in one click.

MCP CRUD

Agents can list, read, create, update, and delete collections, requests, and environments through Clauge's MCP server. The agent can build a whole test suite for you — without ever touching the REST UI.

History

Every request you've ever sent is in the History panel — re-fire, diff against an earlier response, or resurrect a request into a collection.

One editor, every engine, schema-aware AI.

Supported engines

PostgreSQL · MySQL · ClickHouse · SQLite · Cloudflare D1. Same editor, same shortcuts, same AI assistance across all of them.

Adding a connection

1. + New Connection in the sidebar.
2. Choose the engine, fill in host / port / database / credentials.
3. (Optional) attach an SSH tunnel — pick an existing profile from the SSH mode, and Clauge will route the connection through it.

NL → SQL

With a connection open, type a question in the AI panel — "top customers by revenue this quarter" — and Clauge produces schema-aware SQL ready to run. The AI knows your tables, columns, and foreign keys without you pasting a schema dump.

Cross-dialect translation

Have a Postgres query and need its MySQL or ClickHouse equivalent? Highlight it and ask the AI to translate. It rewrites for the target engine's flavor — date functions, window syntax, paginate idioms, all of it.

DataGrip-style statistics

For DML statements (UPDATE / DELETE / INSERT), Clauge surfaces a statistics panel — rows affected, execution time, server-side row counts — alongside the result grid.

Document stores and key-value engines, side by side.

MongoDB

Browse collections like a real database client. The JSON query editor offers auto-format and schema hints; the Aggregation Pipeline builder lets you assemble stages one at a time, previewing the intermediate output between every step.

Redis

Walk keys with TTL and type-aware inspection. Stream support (XADD, XREAD) and pub-sub are first-class. An interactive console lets you run arbitrary commands without leaving the panel.

Engine-aware AI

Ask the AI in plain English — "users on the pro plan inactive 30 days" — and it produces the right query for the engine you're connected to. A Mongo connection gets a find / aggregation; a Redis connection gets a SCAN + filter. It never mixes the two.

A terminal with AI assistance that asks before it writes.

Adding a profile

1. + New Profile in the SSH sidebar.
2. Fill host / port / user. Authenticate via password, public key, SSH agent, or a jump host.
3. Optionally configure port-forwarding — local or remote.

Credentials go straight to your OS keychain. ed25519 is the default key algorithm.

Multiple tabs per host

Right-click any active session → Duplicate Session. You get a fresh terminal tab against the same host without re-authenticating — useful when you need to tail -f in one and run commands in another.

Shared tunnels

SSH port-forwards configured here are available to SQL, NoSQL, and REST. Wire your bastion once and every mode goes through it.

Two AI modes

• Permission mode — every command the AI proposes is gated. A confirm dialog shows the command and the host it will run on; you press Run to execute or Cancel to discard. Destructive commands (rm, shutdown, etc.) trigger a stricter confirmation.
• Auto mode — describe what you need in plain English; the AI executes immediately and streams the output back. Use it when you're moving fast on safe operations.

Switch modes in the AI panel header. Per-profile defaults available in profile settings.

Drive your desktop sessions from your phone.

Turn it on (desktop)

Open Clauge desktop → Settings → Mobile and enable the companion server. It displays a pairing QR code that your phone scans to connect.

Install the app

The Clauge mobile app (iOS & Android) connects to your desktop and mirrors the sessions running there.

Pair

On the phone, scan the QR — or enter the host, port, and code manually. Approve the request on your desktop. Devices you pair appear in the app's device list.

Use a session

The app lists your existing Agent and SSH sessions — tap one to open and mirror it live. Closing with the × ends the session and its desktop tab; going back just detaches and leaves it running so you can reopen it later. The app attaches to existing sessions — it doesn't create new ones.

Remote access (different network)

To reach your desktop when you're not on the same Wi-Fi, use Tailscale:

1. Install Tailscale on both your computer and your phone.
2. Sign in to the same tailnet on both devices.
3. Pair using the desktop's Tailscale address — it appears in the pairing QR when Tailscale is running.

No relay, no extra Clauge account — the connection is direct and encrypted over your tailnet.

Record, transcribe, and summarize meetings — on your machine.

Start a recording

Open the AI Meeting Notes section in Workspace and hit record — or let Clauge detect the call for you. When a meeting app (Zoom, Meet, Teams, Webex, Discord, Slack) takes the mic, a small floating widget appears so you can start recording in one click.

What's captured

Clauge records your microphone and your system audio (the other participants) as two separate, labeled sources, then transcribes locally with Whisper. Both sources land on one time-ordered transcript. Audio is never written to disk — only the transcript is kept.

Models & language

Pick a Whisper model size and language in Settings (or leave language on auto-detect). Larger models are more accurate; smaller ones are faster. Everything runs on-device.

Auto-detect & auto-stop

With detection on, the widget offers to record when a call starts, and the recording stops itself a short while after the call ends. You can also start and stop manually at any time.

macOS permission

To capture the other participants, macOS needs Screen & System Audio Recording permission for Clauge (System Settings → Privacy & Security). Without it, only your microphone is recorded. For clean speaker separation, use headphones — on speaker, your mic also picks up the other side.

Generate AI notes

Turn the transcript into structured notes with your own API key, or with Clauge AI (Pro — no key needed). Notes are generated on demand; the transcript and audio stay local, and meetings are not cloud-synced.

Every backend, one browser, one set of shortcuts.

Backends

Local FS · Amazon S3 (and S3-compatibles: R2, MinIO, Wasabi, DigitalOcean Spaces) · Azure Blob · SFTP · FTP. All unified under one file-browser UI.

One-click presets

When adding an S3-compatible connection, pick a preset (R2, MinIO, Wasabi, DO Spaces, etc.) — Clauge pre-fills the endpoint, region, and path-style flag. Drop your access key and you're connected.

Drag-and-drop

Drop files from your desktop directly into any backend, or right-click a remote file → Download to… to pull it to any local folder. Transfers run in the background; the transfer panel logs every operation with progress and a Cancel button.

AI scan

Ask the AI to summarise the current directory — "what grew today?", "find images larger than 5 MB", "which folder is hogging space?". Returns a short answer with file paths you can click to open.

Inline preview

Text, JSON, and CSV files preview inline — no round-trip download. JSON is pretty-printed; CSV renders as a table.

A queryable log of every session, request, query, and command.

The History mode lives in the left rail. It's a cross-mode log of everything Clauge has done: agent sessions, REST runs, SQL queries, SSH commands, file operations. Filter by mode, date, or text search. Click any entry to jump back to its source mode with the original context loaded.

Connect Claude Desktop, Cursor, or any MCP client to your Clauge.

Clauge ships a built-in MCP server with 30+ tools across boards, cards, notes, REST collections, and coworker coordination. The server auto-starts on app launch — no flag, no separate process to manage.

Default endpoints

• HTTP — http://localhost:7421/mcp
• stdio — pipe directly to the Clauge binary with clauge mcp serve --stdio

From Claude Desktop

Add the following to your claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "clauge": {
      "command": "clauge",
      "args": ["mcp", "serve", "--stdio"]
    }
  }
}

Restart Claude Desktop. You'll see "clauge" under the MCP tools indicator.

From Cursor / Cline / Continue

Point the client at http://localhost:7421/mcp. The agent can now list boards, create cards, append notes, raise PRs, manage REST collections, and call coworkers — all from inside its own UI.

Tool prefixes

Tools are namespaced: boards_*, cards_*, notes_*, rest_collection_*, coworkers_*, workspace_*, activity_feed. One worth knowing about: cards_call_coworker — the agent in your terminal can @-mention a coworker on a card, and the coworker picks it up just like a human assignee.

Sign in once, work from any machine.

Sign in with Google or GitHub from Settings → Account, and Clauge starts syncing your workspace across the machines you've signed in on. Sign out, or skip sign-in entirely, and Clauge runs fully offline — every mode keeps working, nothing leaves your device.

Sync is automatic when you're signed in. There's no "what to sync" dial to turn — Clauge mirrors what's needed for your workspace to feel the same on a second machine. Everything that moves is encrypted in transit and at rest.

The keystrokes worth memorising.

Things people ask.

Is Clauge free?

The desktop app is free for personal use under the PolyForm Noncommercial license. Commercial use requires a licence — see the Enterprise page or email support@clauge.in.

Do I have to sign in?

No. The sign-in screen on first launch has a Skip for now option — Clauge runs fully offline without an account. Sign in later from Settings → Account if you want cloud sync or Clauge AI credits.

Does Clauge see my code or prompts?

The AI providers you configure (Anthropic, OpenAI, Google, OpenCode, or Clauge AI) see only the prompts and context you send them inside a session. Clauge itself doesn't read your code or upload it anywhere unprompted.

How do I update?

Clauge checks for new releases on launch and offers an in-app update when one's available. You can also download the latest build any time from clauge.in.

How do I report a bug?

github.com/ClaugeHQ/Clauge/issues. Include your OS, Clauge version (Settings → About), and a repro if you can.

Will Clauge add more modes?

Yes. New modes ship alongside the existing ones — follow the changelog to see what's landing.