autonomous Claude Code fleets, one command away

Feed it tickets. Harvest PRs.

Grove turns each ticket into an autonomous Claude Code worker — its own git worktree, its own tmux window, its own pull request. You write tickets and say yes. The grove does the rest.

Install grove → Read the story ↓
~/projects/shopfront — one product, two repos
~/projects/shopfront $ lswebapp/ api/# a frontend and its backend. independent repos,# one shared folder. not a monorepo. ~/projects/shopfront $ gv init🌱 taking root… ├───── webapp/ ✓ pnpm · main └───── api/ ✓ go · main workspace rooted · 2 repos · gv doctor ✓ green
Act I

It gets comfortable.

Plant grove in a project — the folder that keeps a product's repos together: a frontend here, its backend there. It doesn't ask you to restructure anything — it walks in, looks around, and settles in.

i.

Spread out

gv init probes every repo in the project: the stack, the base branch, the setup command a fresh worktree needs. One grove per project — and run gv anywhere else, it simply asks which project you mean.

$ gv init scanning ~/projects/shopfront … ✓ webapp pnpm workspace, base: main ✓ api go module, base: main
ii.

Wire itself up

The connections board fills in — tmux, GitHub, Claude, hooks. And gv doctor notices the moment any of it drifts, so “it worked last week” never becomes a mystery.

$ gv doctor ✓ tmux 3.4 ✓ gh authed ✓ claude on PATH ✓ hooks installed ○ linear no API key — want one? →
iii.

Hook into your tasks

Point it at wherever your tickets already live — GitHub Issues by default, Linear or plain markdown files as adapters. Grove reads tickets; it never closes them. That's your job, and it stays your job.

# .grove/config.yaml provider: kind: github # or linear, or markdown # tickets are your issues: webapp-14 = issue #14
Act II

Feed it a ticket.

One command. Grove cuts a fresh worktree, opens a tmux window, and launches a worker with a kickoff prompt built from the ticket itself.

one ticket → one worker → one PR
$ gv grab DEV-123 --repo webapp
  • ├─ worktree cut ~/git/.worktrees/webapp/DEV-123 — isolated, disposable, yours to inspect
  • ├─ tmux window up the worker lives here — attach anytime with gv attach DEV-123
  • ├─ kickoff prompt built from the ticket: title, description, comments, acceptance criteria
  • └─ PR opened “Closes DEV-123” · CI running · STATUS: DONE on your dashboard

The worker investigates, implements, commits, pushes, reviews its own work, and reports back with a one-line status: DONE, QUESTION, or BLOCKED. Questions land on your dashboard with a drafted answer already waiting — most of the time, unblocking a worker is just saying yes.

Act III

Teach it how you like to review.

Workers run inside a worktree of your repo — so your .claude/ skills, agents, and CLAUDE.md come free. Tell grove your review taste once, and every worker honors it, fleet-wide.

❯ orchestrator chat
you
For webapp tickets, have workers use the browser-control skill: screenshot the change and post it to the ticket before opening the PR.
orchestrator
Added to the webapp kickoff template. Every webapp worker will now run the app, capture before/after screenshots, and attach them to the ticket as its last step before the PR. Want the same for mobile?
◈ DEV-123 · Linear
DEV-123 · webapp
Empty cart state shows broken illustration
worker/DEV-123 · bot · 2 min ago
before
after
📸 before/after attached — PR #98 ready for review.
status: In Review  ← workers move tickets here, never to Done

Review from the couch. The screenshot is on the ticket, the diff is a gv diff DEV-123 away, and merging stays a human's decision — grove never touches a ticket's terminal state.

Act IV

The rhythm.

The practice that makes parallel work feel effortless: chats are disposable, state is durable. Here's a real morning.

a tuesday, condensed
09:04 O new chat: “find me 3 easy tickets” → ranked table, one grab command per row → “grab all 3” 09:11 ✕ chat closed. workers don't need you watching. ──── three workers grinding in parallel ──── 11:30 O new chat: “anything need me?” → DEV-121 ✓ PR ready · CI green, review queued → DEV-122 ? question — asks about the API shape (answer drafted — you just say yes) → DEV-123 ◌ CI running · nothing to do yet 11:34 ✕ closed again. lunch.
One chat per investigation.

Parallel threads never share a scrollback. Triage in one chat, unblock in another, cost report in a third — each stays sharp.

Close it when the worker spawns.

The chat was scaffolding; the worker is the building. Once it's dispatched, the chat has nothing left to hold for you.

Open a fresh one to catch up.

Fleet state lives in .grove/, not in chat history. A brand-new orchestrator re-derives everything from gv ls in one command.

Parallelizing is cheap because forgetting is impossible.

For the scanners

Everything in the toolshed.

◧

Cockpit dashboard

One tmux session: live fleet table on the left, orchestrator chats stacked on the right. One glance answers “who needs me?”

≡

Backend-agnostic tasks

Local markdown by default; Linear and GitHub Issues as adapters. Grove reads tickets, agents transition them, humans finish them.

⇅

Model routing

Rote work goes to small models, hard reasoning to frontier ones — and failed gates escalate upward, never silently down.

⛨

Guardrails, not vibes

Never closes tickets. Never deletes worktrees it didn't create. Propose, then dispose — irreversible actions wait for your yes.

⌕

Audit & sweep

Cross-checks every task against reality: merged, drifted, abandoned, disconnected. Orphans get reported — removal is your call.

Σ

Cost ledger

Per-ticket token estimates joined to PR outcomes. See which ticket shapes burn tokens and what a merged PR actually costs.

In the works — plugins. Grove's --json output and append-only events.jsonl are a stable contract, so new surfaces grow outside the core: a reMarkable e-ink fleet dashboard already builds against it, and your Notion board or Discord bot could be next.

Plant your own

Install.

one line — prebuilt binaries, macOS & Linux
$ curl -fsSL https://raw.githubusercontent.com/JollyGrin/grove/main/install.sh | bash $ gv doctor # preflight: tmux, gh, claude $ cd ~/projects/your-app && gv init # 🌱 take root $ gv # open the cockpit $ gv update # any time later: newest release, in place # or from source (Go 1.26+): $ go install github.com/JollyGrin/grove/cmd/gv@latest
your first harvest — tickets are your GitHub issues
$ gh issue create --title "empty cart shows broken illustration" → created issue #14 $ gv grab your-app-14 --repo your-app # worktree + worker + kickoff prompt $ gv ls # … a coffee later: your-app-14 ✓ PR ready · CI green — review & merge

Daily loop

$ gv # cockpit: dashboard + orchestrator $ gv grab DEV-123 --repo webapp $ gv ls # fleet table $ gv attach DEV-123 # jump into a worker $ gv answer DEV-123 "yes" # unblock a question $ gv diff DEV-123 # review without attaching $ gv done DEV-123 # verify merged → clean up

You'll need

✳
tmux
cockpit + every worker live here
✳
gh
PR & CI state — merges checked via GitHub, never git ancestry
✳
claude
Claude Code CLI, logged in
✳
Go 1.26+
only if building from source — the installer ships prebuilt binaries

Grove is the successor to parkranger — built when editing the code was still first-class: the worktree, the file tree, the diff front and center. Agentic coding flipped that. You can still attach to any worker, but the first-class surface is now the tasks and the orchestration.