Gooey: A Desktop Command Center for Claude Code

Claude Code is brilliant at writing, refactoring, and explaining code — but juggling multiple projects, sessions, and agent behaviors from the terminal can get messy fast. Gooey turns that chaos into clarity. It’s a native-style desktop app (built on Tauri) that wraps Claude Code in a clean, powerful GUI so you can create custom agents, manage interactive sessions, run secure background agents, organize projects, track usage, and even wrangle MCP servers all in one place.

This article walks you through what Gooey is, why each feature matters in day-to-day development, and exactly how to run and deploy it whether you’re a solo builder or coordinating a small team.

Note: Gooey is an independent open-source project and isn’t affiliated with Anthropic.

What Gooey Is (in one sentence)

A desktop toolkit that makes Claude Code session management, agent creation, and automation feel effortless — without giving up local control or security.

The Core Features (and why you’ll care)

1) Project & Session Management

What it does: Gooey scans your Claude Code workspace (typically ~/.claude/projects/) and gives you a visual browser of projects and session histories. You can search, resume, or start new sessions with full context.
Why it matters: Terminal history is ephemeral. A visible timeline of “what we discussed” keeps momentum between sessions and makes collaboration (or handoffs) painless.

2) Custom “CC Agents”

What it does: Define specialized agents with names, icons, system prompts, and permissions. Run them in the foreground or as background processes; inspect logs and run history.
Why it matters: Different jobs need different personalities documentation writer, test-first refactorer, API contract stickler. Codifying these as reusable agents turns “good prompts” into repeatable workflows.

3) Usage Analytics Dashboard

What it does: Track costs and tokens by model, project, and time period, complete with exportable charts.
Why it matters: When AI becomes part of the build loop, visibility into spend and model mix stops guesswork and prevents end-of-month surprises.

4) MCP Server Management

What it does: Add, import, and test Model Context Protocol servers (including configs imported from Claude Desktop) in one UI.
Why it matters: Tools are multiplying. Centralizing MCP servers removes config drift and makes it safer to extend your assistant with new capabilities.

5) Timeline & Checkpoints

What it does: Create checkpoints, branch/fork sessions, and diff changes across time with a visual timeline. One click restores prior state.
Why it matters: You’ll experiment more when “undo” is trustworthy. Checkpoints let you explore aggressively and keep a clean path back to “known good.”

6) CLAUDE.md Management

What it does: Built-in editor and live preview for CLAUDE.md, plus a project scanner to find and maintain these files.
Why it matters: Your house rules, coding standards, and repository-specific context live in CLAUDE.md. Keeping it discoverable and consistent dramatically improves agent outputs.

7) Security by Default

What it does: Local-first storage, no telemetry, permission controls per agent, and process isolation for background runs.
Why it matters: You get a rich GUI without sacrificing privacy or letting agents roam beyond your intended boundaries.

Under the Hood (tech you can trust)

Gooey ships as a Tauri 2 desktop app with a React + TypeScript front-end and a Rust backend, using SQLite for local data. In practice, this means native feel, small footprint, and speed on macOS, Windows, and Linux. It’s open-source under AGPL-3.0.

How to Install & Run

Option A — Build the desktop app locally (fastest today)

Gooey requires the Claude Code CLI to be installed and on your PATH. Verify with claude --version.

1. Install prerequisites

• Rust (via rustup)
• Bun (JavaScript runtime/packager)
• Git
• Platform extras: WebKit/GTK dev libs on Linux; Xcode CLTs on macOS; MSVC Build Tools + WebView2 on Windows.

1. Clone & install deps

git clone https://github.com/getAsterisk/gooey.git
cd gooey
bun install

1. Run in dev (hot-reload)

bun run tauri dev

1. Produce a native build

bun run tauri build
# Artifacts land in src-tauri/target/release/ (DMG/MSI/DEB/AppImage/EXE)

If anything fails, check the README’s troubleshooting section for missing toolchains or platform libraries (e.g., WebKit GTK on Linux).

Prefer installers? Watch the repo’s Releases they publish packaged builds for macOS, Windows, and Linux.

First-Run Tour (5 minutes to productive)

1. Launch Gooey → choose Projects or CC Agents on the welcome screen. Gooey auto-detects your ~/.claude directory.
2. Projects view → pick a repo; scan prior sessions; resume or start a new one.
3. Create an Agent → name + icon, write its system prompt, select a model, set file/network permissions, and save. Now you can run it on any project.
4. Usage Dashboard → open the menu to see costs/tokens by model and project; export if needed.
5. MCP Manager → add or import servers, test connectivity, and keep them in a single registry.
6. Checkpoints → as you work, create timeline checkpoints; branch/fork if you want to explore an alternative approach.

Everyday Workflows That Shine

A) “House Style” Agents

Create agents for your team’s conventions TypeScript-first, PNPM enforced, strict ESLint. Run them against new repos to bootstrap standards quickly. (Make the rules explicit in CLAUDE.md and keep it fresh with the built-in editor.)

B) Spikes with a Safety Net

Use checkpoints before big refactors; fork a branch in the timeline to try another path. The diff viewer makes it obvious which approach is cleaner.

C) Usage Reviews

Close a sprint by exporting model usage for accounting. If costs are creeping up, tighten high-token prompts or move routine tasks to cheaper models.

D) Tooling Experiments via MCP

Add a new MCP server for, say, repository search or incident runbooks. Test it in the manager, then roll it out to the agents that need it without scattered config files.

Deployment Notes (Teams & Lab Machines)

• Local-first by default: Everything lives on your machine; no telemetry. Great for offline or privacy-sensitive work.
• Signed builds: Use packaged release artifacts (DMG/MSI/DEB/AppImage) for non-dev teammates to avoid toolchain setup.
• Policy control: Encourage agents with limited file/network permissions for risky repos; elevate only when necessary.
• Backups: Since sessions and checkpoints are valuable, include Gooey’s local data folder in your workstation backup routine.

Troubleshooting (quick hits)

• claude not found: Install the Claude Code CLI and ensure it’s on PATH; verify with claude --version.
• Linux build errors about WebKit/GTK: Install the listed libwebkit2gtk, libgtk-3-dev, and related dev packages.
• Windows “MSVC not found”: Install the Microsoft C++ Build Tools; restart your shell.
• Memory pressure while building: Use a debug build or reduce parallel jobs.

Open Source, For Real

Gooey is AGPL-3.0 licensed, with TypeScript and Rust as primary languages. Contributions are welcome (features, docs, tests, i18n). If you’re curious about the internals, check the repo’s structure and Dev commands in the README.

Conclusion

Gooey doesn’t try to replace Claude Code it amplifies it. With session timelines, reusable agents, background runs, cost visibility, MCP management, and CLAUDE.md tooling, it turns AI-assisted coding into a reliable, transparent, and team-friendly practice.

Target goal for your first day:

• Build or install Gooey,
• Create one “house style” agent,
• Resume an old session and set two checkpoints, and
• Wire up one MCP server you’ve been meaning to try.

You’ll feel the difference the next time you ship a feature and every time after that.