Clauge

One window. Every dev tool.

Coding agents · workspace · REST · SQL · NoSQL · SSH · file explorer
— every tool, one shell, an AI tuned to each.

Website · Changelog · Download → · Report a bug

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

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

Switch the modes using ⌘1–⌘7;

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.

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 with 45+ tools — boards_*, cards_*, notes_*, rest_collection_*, coworkers_*, workspace_*, activity_feed, and cards_call_coworker (so the agent in your terminal can @-mention a coworker on a card without leaving the shell). The server auto-starts on launch — no flag, no extra setup. Any MCP-speaking client can drive your workspace.

From Claude Desktop

Add to your claude_desktop_config.json:

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

From Cursor / Cline / Continue

Point your MCP client at the local Clauge process (stdio or http://localhost:7421/mcp). The agent can now list boards, create cards, append notes, raise PRs, search REST collections, and coordinate with the named coworkers you defined inside the app — all without leaving its own UI.

AI assistance — bring your own key, or use Clauge AI

Every mode's AI runs on the provider you choose.

Set keys in Settings → AI Providers. Per-mode model choice; per-session model override.

Cloud sync

Opt-in, per-feature, encrypted. Your boards, notes, REST collections, and SSH profiles sync across machines — or stay local, your call. Sessions and credentials never leave the device unless you explicitly enable sync for them.

Built with

• Frontend — SvelteKit + Svelte 5
• Native shell — Tauri v2 (Rust)
• Persistence — SQLite (local), optional encrypted cloud sync
• Terminals — xterm.js + cross-platform PTY
• MCP — built-in JSON-RPC server, stdio and HTTP transports

License

This project is licensed under the PolyForm Noncommercial License 1.0.0 .

Contributions require signing a Contributor License Agreement (CLA). See Contributor License Agreement for details.