Clauge

You've been flipping between multiple apps to do one job. Clauge runs all of them in one shell — coding agents, an API client, SQL and NoSQL editors, SSH sessions, a remote file browser, and a project workspace — and gives each mode its own AI, tuned for that workflow. Every mode is one keystroke away. Your data stays on your machine.

Modes

| | Mode | What it does | Key capabilities | |---|---|---|---| | 01 | Agent | Run multiple coding agents in parallel — each with its own purpose, git worktree, and context. | Claude · Codex · Gemini · OpenCode · purpose-pinned sessions · Context Manager · Plugin Manager · per-session git identity · usage analytics | | 02 | Workspace | Boards + notes your agents can read, write, and act on. | Kanban boards · markdown notes · AI coworkers · GitHub & GitLab issue import · full MCP integration | | 03 | REST | An API client your AI — and any external agent — can drive. | Collections · environments · AI batch runner · MCP-exposed (agents create / read / update / delete collections and requests) | | 04 | SQL | One client, every engine. | PostgreSQL · MySQL · ClickHouse · SQLite · Cloudflare D1 · schema-aware AI · cross-dialect translation · SSH tunnels shared with other modes | | 05 | NoSQL | Document and key-value stores, side by side. | MongoDB · Redis · aggregation pipeline builder · interactive Redis console · engine-aware AI | | 06 | SSH | A terminal with an AI co-pilot. | Profiles · multi-tab per host · port forwarding · keychain-backed creds · two AI modes: permission-gated and auto | | 07 | Explorer | Every storage, one browser. | Local FS · S3 (and S3-compatibles) · Azure Blob · SFTP · FTP · drag-and-drop transfers · AI scan |

Plus a cross-mode History layer — a queryable log of every session, request, query, and command across modes.

Inside each mode

Agent

Spawn coding agents in parallel — Claude, Codex, Gemini, OpenCode — without ever leaving the editor. Each session is independent: its own git worktree, its own context, its own model.

Per-session controls:

• Purpose — pin the session's intent up front (see table below)
• Git identity — commit as a coworker, not yourself
• Skip permissions — for fully-autonomous runs when you trust the prompt
• Context injection — pin files, folders, or MCP servers via the Context Manager (save sets, reuse across sessions)
• Plugins — load extra tools from the Plugin Manager

Purposes

Every Clauge 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.

| Purpose | What the agent focuses on | |---|---| | Brainstorming | Architecture, tradeoffs, multiple approaches — before writing a line | | Development | Clean, tested, pattern-consistent code shipped in small verified steps | | Code Review | Bugs, security holes, edge cases — with file and line references | | PR Review | End-to-end pull-request analysis: what changed, what's good, what needs work | | Debugging | Root cause, not band-aids — reproduce, trace, verify the fix actually works | | Custom | Import an existing Claude Code session or define your own mode |

Every session emits usage analytics — tokens in / out, cost, cache hit, model mix — per session and aggregated across your day.

Workspace

A shared layer your agents can read, write, and act on through MCP.

• Kanban boards — Backlog → Todo → In Progress → In Review → Done. Review is a safety gate, not a column you skip past.
• Two-way Git integration — pull open issues from GitHub and GitLab into a board, push finished cards back as pull requests.
• Project linking — point a workspace at a git repo and Clauge auto-spawns one board per subproject.
• Notion-style notes — a real WYSIWYG markdown editor, not a textarea. Per-project, linked to sessions, exposed through MCP.
• AI coworkers — named personas (Tech Lead, Brainstormer, Developer, Reviewer, QA) with their own prompts and providers. They read cards, comment, request changes, claim work, commit, and raise PRs.
• Single-owner lock — only one coworker (or one terminal session) owns a card at any moment. Switching owners, claiming from a terminal, and chatting in the card drawer all go through the same lock — no race conditions, no lost work.
• Pinned Inbox — mentions, review requests, and approval queues across every board, in one pane.
• Cross-board search — instant full-text search across every note and card.
• Default-on MCP — boards, cards, notes, and @-mention a coworker are all MCP tools an external agent can call. Auto-starts when the app launches — no flag, no setup.

REST

An API client driven by AI and exposed over MCP.

• MCP integration — external agents can list, read, create, update, and delete collections and requests.
• AI assistance — describe an endpoint and the AI writes the request; ask "run the smoke tests in staging" and the AI fires the whole collection.
• Execution reports — pass / fail summary with the failing request inline.
• Collections, environments, request history, Postman v2 / v2.1 import.

SQL

One editor, multiple engines, schema-aware AI.

• Engines — PostgreSQL · MySQL · ClickHouse · SQLite · Cloudflare D1
• AI assistance — natural language → schema-aware SQL, ready to run
• Cross-dialect translation — Postgres → MySQL → ClickHouse; AI rewrites the query for the target engine
• SSH tunneling shared with other modes — wire your bastion once, all modes use it

NoSQL

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

• MongoDB — collections, JSON query editor, stage-by-stage aggregation pipeline builder with previews
• Redis — keys, TTL, streams, pub-sub, interactive console
• Engine-aware AI — never confuses a find with a SCAN

SSH

Persistent SSH with two AI modes:

• Permission mode — every command the AI proposes is gated; you approve before it touches the wire.
• Auto mode — describe what you need; the AI executes and streams the output back.

Plus: reusable profiles, multiple tabs against the same host (no re-authenticating), port forwarding, ed25519 and agent forwarding, keychain-backed credentials.

Explorer

Every backend, one browser, one set of shortcuts.

• Backends — Local FS · Amazon S3 (and S3-compatibles like R2, MinIO, Wasabi) · Azure Blob · SFTP · FTP
• One-click presets — pre-configured profiles for the common S3-compatible providers, so connecting takes seconds
• Drag-and-drop transfers — drop files into any backend, right-click "Download to…", with a live transfer panel showing progress and cancel
• AI assistance — "what grew today?", "find images larger than 5 MB" — natural-language file ops
• Inline preview — text, JSON, CSV without a round-trip download

What makes Clauge different

One window, not many. Every developer's day is fragmented across a code editor, a REST client, a SQL GUI, a Mongo shell, a terminal, and a project board. Clauge collapses all of them into one shell with shared sessions, shared SSH tunnels, and shared AI context — switch modes with one keystroke.

An AI per workflow, not a generic chat. REST's AI understands your collections. SQL's AI knows your schema. SSH's AI refuses destructive commands without confirmation. The Workspace AI moves cards, leaves comments, and raises pull requests. Each one is tuned for what it sits next to — not a single chatbot bolted onto the side.

Built-in MCP server, not a plug-in. Clauge runs an MCP server out of the box, exposing 45+ tools across boards, cards, notes, REST collections, and coworker coordination. Claude Desktop, Cursor, Cline, Continue, or any MCP-speaking client can read, edit, and add to your workspace from the outside.

Local-first by default. Your sessions, your notes, your queries, your keys live on your disk. The desktop app is the source of truth. Sync is opt-in, per-feature.

Native. Rust + Tauri. ~20 MB binary. Sub-second cold start. No Electron tax.

MCP

Clauge ships an MCP server wit