v0.4.5 · MIT License · macOS & Linux

Run 10 AI agents.
Zero context switching.

Manage multiple AI coding tasks in parallel. Each task gets its own Git worktree, terminal session, and AI context — isolated, organized, always ready to resume.

Works with
Claude Code Cursor GitHub Copilot CodeX Trae Gemini Amazon Q Qwen Kimi any AI agent
Get Started View on GitHub
Terminal
$ curl -sSL https://raw.githubusercontent.com/GarrickZ2/grove/master/install.sh | sh
✓ Grove v0.4.5 installed successfully
$ cd my-project && grove
🌲 Grove TUI launched — 4 tasks ready

Your workflow shouldn't fight your tools

Traditional Git workflows break down when you run multiple AI agents. Grove fixes that.

Constant git stash / git stash pop gymnastics just to switch context

Instant switching — each task has its own worktree, no stashing needed

Branch switching kills terminal state, scrollback, and running processes

Sessions persist — tmux/Zellij keeps everything alive across restarts

Multiple AI agents conflict and overwrite each other’s changes

Full isolation — 10 agents run in parallel without stepping on each other

“Wait, what was I working on?” moments after every switch

Resume instantly — every task remembers exactly where you left off

Without Grove
With Grove

Each task gets its own isolated universe

A dedicated Git worktree, terminal session, and working directory. All managed from one beautiful interface.

Grove workflow demo
1

Create

Press n to create a task. Name it, pick a target branch, and Grove sets up a new Git worktree + terminal session automatically.

2

Work

Press Enter to jump into the task. Each session is fully isolated — fire up AI agents, edit code, run tests, all in parallel.

3

Complete

Press Space to open the action menu — merge back to target, archive, or delete. Grove handles all the Git plumbing.

Three interfaces. One backend.

Choose the interface that fits your workflow. All three share the same data and backend — switch freely between them.

Terminal UI

TUI — grove

A full-featured terminal interface built with Ratatui. Navigate tasks, preview Git diffs, read review comments, and manage your entire workflow without leaving the terminal.

  • ✓ Keyboard-driven — every action has a keybinding
  • ✓ Tab-based task organization: Current, Other Branch, Archived
  • ✓ Preview panel with Git, Notes, Review, and Stats tabs
  • ✓ Real-time status indicators: ● Live ○ Idle ✓ Merged
  • ✓ Inline search with /, theme switching with t
Grove TUI with task list and preview panel
Grove Web UI dashboard
Web UI

Web — grove web

A full-featured web interface embedded directly in the binary — no separate deployment needed. Serves on localhost:3001 by default.

  • ✓ Integrated terminal via WebSocket (xterm.js)
  • ✓ Monaco Editor with file tree for in-browser editing
  • ✓ Git operations: branches, checkout, pull, push, stash
  • ✓ Activity stats, file edit heatmap, commit history
  • ✓ Code review panel with inline comments
$ grove web # Open http://localhost:3001
$ grove web --port 8080 # Custom port
Desktop GUI

GUI — grove gui

A native macOS desktop application powered by Tauri 2. Shares the same React frontend as the Web UI, but runs in a native window — no browser tab needed.

  • ✓ Native macOS window (1440×900, resizable)
  • ✓ Same features as Web UI in a dedicated app
  • ✓ Included by default in macOS release binaries
  • ✓ Via cargo: cargo install grove-rs --features gui
$ grove gui # Launch native window
$ grove gui --port 8080 # Custom API port
Grove native macOS GUI

Feature Gallery

Click a feature to preview it.

Integrated Terminal

Full xterm.js terminal via WebSocket

Monaco Editor

In-browser code editing with file tree

Code Review

Diff view with inline review comments

Task Notes

Context and requirements per task

Activity Stats

File edit heatmap and timeline

Hook Notifications

Real-time agent notification inbox

Feature preview

Everything you need for parallel AI workflows

Built from the ground up for developers who use AI coding agents every day.

Git Worktree Isolation

Each task gets its own branch, working directory, and terminal. No stashing, no conflicts — work on 10 features at once.

Session Persistence

tmux or Zellij sessions survive restarts, crashes, and reboots. Terminal scrollback, environment variables — everything preserved.

tmux & Zellij

Choose your multiplexer. Grove supports both tmux and Zellij with KDL layout files for custom pane configurations.

MCP Server

Built-in Model Context Protocol server. AI agents read notes, reply to code reviews, and complete tasks autonomously.

Hook Notifications

Get alerted when AI finishes work. Three severity levels (notice / warn / critical) with system sound + banner notification.

Code Review

View review comments inline, reply with resolved/not_resolved status. AI agents can reply to reviews via MCP tools.

Preview Panel

Press p to toggle a side panel with four tabs: Stats (heatmap), Git (diffs/commits), Notes (editable), and Review (comments).

11 Built-in Themes

Dracula, Nord, Gruvbox, Tokyo Night, Catppuccin, Rosé Pine Dawn, Solarized Light, and more. Auto-detects your system preference.

Custom Layouts

5 presets: Single, Agent, Agent+Shell, Agent+Monitor, Grove+Agent. Or build your own custom split layout.

Use any agent you like

Grove is agent-agnostic. Claude Code, Cursor, GitHub Copilot, Windsurf, Aider — any AI coding tool works. Grove provides the isolation and context layer; you choose the agent.

MCP protocol support
CLI hooks for any tool
Standard Git worktrees
No vendor lock-in

MCP Server

Grove provides a Model Context Protocol server that gives AI agents (Claude Code, Cursor, etc.) direct access to task context. The agent can read your notes, check review comments, and even complete the task — all through structured tool calls.

Available MCP Tools

grove_status Detect if running inside a Grove task. Returns task ID, branch, target branch, and project name.
grove_read_notes Read user-written notes containing context, requirements, and instructions for the task.
grove_read_review Read code review comments with IDs, file locations, content, and status (open/resolved).
grove_reply_review Batch reply to review comments and set status to resolved or not_resolved.
grove_complete_task Complete the task in one call: commit changes, rebase onto target branch, and merge.

Setup — add to Claude Code config

// ~/.claude/config.json
{
  "mcpServers": {
    "grove": {
      "command": "grove",
      "args": ["mcp"]
    }
  }
}
Grove supports multiple AI agents in parallel

End-to-End AI Workflow

1

Create Task

You create a task in Grove. A new Git worktree and terminal session are set up automatically.

2

Agent Reads Context

AI agent calls grove_status and grove_read_notes via MCP to understand the task.

3

Agent Works

Agent codes in the isolated worktree. Reads reviews, replies to comments, sends notifications via hooks.

4

Agent Completes

Agent calls grove_complete_task to commit, rebase, and merge — all in one step.

Agent Hook Notifications

Let your AI agents notify you when they're done. Trigger system notifications with sound from within agent scripts or MCP tool calls. Press h in the TUI to configure sounds and banners.

# Three severity levels
$ grove hooks notice -m "Task completed"
$ grove hooks warn -m "Needs your review"
$ grove hooks critical -m "Build failed"

# Custom sound
$ grove hooks notice --sound Purr
Grove
Grove now

Task completed

fix-auth-bug — All changes committed and merged.

Grove
Grove 2m ago

Needs your review

add-oauth — Agent has questions about the implementation.

Grove
Grove 5m ago

Build failed

refactor-db — 3 tests failing after migration changes.

11 Themes + Auto

Press t to open the theme selector. Grove auto-detects your system dark/light preference, or pick your favorite manually. Each theme includes a 10-color accent palette for project card gradients.

Dracula
Nord
Gruvbox
Tokyo Night
Catppuccin
Rosé Pine Dawn
Solarized Light
GitHub Light
Light
Catppuccin Latte
Dark (default) + Auto
Grove theme showcase - Dracula, Nord, Gruvbox, Tokyo Night and more

Session Layouts

Configure how terminal panes are arranged when you open a task session. Choose a preset or design your own split layout.

Shell

Single

Default shell

Agent

Agent

Auto-starts AI

Agent
Shell

Agent + Shell

60/40 split

Agent
Monitor
Shell

Agent + Monitor

Agent + 2 panes

Grove
Agent

Grove + Agent

Monitor + AI

Keyboard-first design

Every action is a single keystroke away. No menus to navigate, no mouse required.

New task n
Open task session Enter
Action menu Space
Navigate up/down j / k
Switch tabs Tab
Search tasks /
Toggle preview p
Change theme t
Hook settings h
Edit notes e
Help ?
Quit q

Install in 10 seconds

Single binary with embedded web frontend. No runtime dependencies beyond Git and a terminal multiplexer.

$ curl -sSL https://raw.githubusercontent.com/GarrickZ2/grove/master/install.sh | sh
Auto-detects platform (macOS/Linux) and architecture (x86_64/aarch64). GUI included on macOS.

Then just run:

$ cd your-project && grove # TUI
$ cd your-project && grove web # Web UI
$ cd your-project && grove gui # Desktop GUI
Git 2.20+ tmux 3.0+ or Zellij macOS 12+ or Linux