Grove

Grove is a local-first terminal-based toolkit for organizing AI-assisted software development. It aims to make coding with AI feel more deliberate, controlled, and fun.

Guiding Design Principles

1. Explicit Context Engineering

Context engineering is critical for making AI coding feel controlled and accurate. Context should be curated or reviewed by a human during planning (especially if context for a task exceeds 200K tokens) and this process should be quick and easy. Disciplined context curation clarifies the mental model and scope of a task for both humans and LLMs.

Glob-Based Rules

Define exactly what’s important using .gitignore-style patterns.

grove’s cx tool for building context.

Context Curation

The cx tool resolves these patterns to a list of files for token analysis, file concatenation, and passing file lists to agents to read.

Plan vs. Execute

Submit entire codebases to LLM APIs like Gemini 3 Pro to generate high-quality plans, then feed those specific plans to coding agents (like Claude Code) for implementation. This significantly speeds up development. I use it as a replacement for “Plan Mode”.

Persistence

cx makes it possible to define glob-based rule sets and save them, reference them from other projects, clone repos, etc. It’s a way to slice up codebases into lists of files.

2. Plain Text, Markdown-Based Orchestration, and Logs

Grove minimizes use of databases, instead emphasizing text files. They can be commited, easily passed to LLMs to read, and be bundled in context/API submission. Workflows are defined as Plans—directories of Markdown files where each file represents a Job.

Structured Execution

Jobs define dependencies (depends_on), creating a Directed Acyclic Graph (DAG) of tasks. Jobs can contain rough ideas, bug ideas, complete, specifications. They can submitted to LLM APIs, along with portions of the codebase, to append create oneshot plans, or can serve as a back-and-forth (with the codebase in context). They’re used in “briefings” to explain to agents, which then append their logs to the same Markdown file,

Structured briefings

every job has an associated “briefing file” that instructs what files the LLMs should pay attention to the user instructions. Context can be selectively prepended to the briefing file if something needs extra attention.

In grove’s flow tool, APIs and agents are given “briefings”, which are XML documents containing a customized mix of context, lists of local or uploaded files, templated system prompts, and user prompts.

Persistence

Plans are saved in the repository or a paired notebook, preserving the chain of thought, specifications, and execution logs long-term. All history is potentially useful in AI software development, and grove emphasizes keeping an audit trail that is easy to feed into context or agents.

Artifacts from a plan’s execution are preserved and viewable with grove’s notebook tool (see below).

Flexibility

Supports multiple execution modes, including oneshot API calls, interactive_agent sessions (via tmux), and multi-turn chat.

Workspaces

Grove’s Workspace Model enables users to configure what directories on their system should be known to Grove. It’s a bit like tmux-sessionizer on steroids. Workspaces are used by all of Grove’s tools: flow to manage plans and worktrees, nav for jumping between projects, cx for cross-repo context building, and hooks for tracking where agents are working and what outstanding work exists in which project.

Worktrees

Most work should be done in worktrees for clarity and parallelism. Worktrees map neatly to how Grove manages Plans and Notes.

Ecosystems

Grove has a concept of an Ecosystem — or a group of related repositories. Grove can instantiate synchronized worktrees across multiple repositories simultaneously, allowing agents to make concerted changes across microservices or libraries.

It should be easy to jump to what you want in a few keystrokes. Grove encourages binding its various TUIs to tmux popups for fast access. It has Neovim key bindings for editing context, running chats, etc.

grove’s nav keymap operates like a “recent favorites” menu, mapping workspaces to key shortcuts. In the example above, grove website is initially bound to <leader>-w, but then we move a flow debugging worktree to that position and a bake-off worktree to <leader>-e.

Observability

Grove uses agent hooks and scans notebook file frontmatter to see what work is ongoing, completed, or waiting for user input. It offers a view of “what am I actually working on right now” across all the workspaces, .

grove’s hooks TUI tracks the status running flow jobs across grove’s Workspaces.

CLIs

Grove’s CLIs can return JSON (for various state info) or can be run by LLMs. For example an agent can curate context with cx CLI, construct a flow graph of Markdown files and run these, then monitor the status of agents/chats with flow status and hooks. It can introspect workspaces to understand where things are.

The cx tool can be used by agents to assemble context. This is similar to what Claude Code does in Plan Mode, but it saves the results into a file list for review/perisistenced. You can have the agent figure out what it thinks is important/relevant, then confirm its understanding, revise it, and save the results/associate the curated context with a particular plan.

TUIs

For humans, each package as a TUI for convenience

Git

Grove uses git extensively for observing what changed across Workspaces and worktrees.

4. Repo-Paired Notebooks

Knowledge management is tightly coupled to the code but stored separately to persist across branches.

Central Knowledge Base

Store plans, technical notes, and logs in a nb notebook linked to your repository.

Bidirectional Flow

Launch workflows directly from notebook entries, or instruct agents to write documentation, issues, and new ideas back into the notebook.

Skills & Concepts

Define reusable agent SKILL.md files and maintain “Concept” documents that explain complex architectural patterns to agents, reducing the need for repetitive prompting.

asciinema

{
  "src": "/docs/overview/asciicasts/nb-demo.cast",
  "poster": "npt:0:32",
  "autoPlay": false,
  "loop": false
}

!Fig. Grove’s notebook tool, nb

The Toolchain

Grove is a composable suite of independent CLI tools that can be used individually or orchestrated together.

tool-showcase

{
  "tools": [
    {
      "name": "grove",
      "title": "grove",
      "description": "The meta-CLI and package manager. Manages tool installation, updates, and binary resolution for local development.",
      "docs": "/docs/grove/01-overview/"
    },
    {
      "name": "cx",
      "title": "cx",
      "description": "The context engine. Generates context blobs based on glob rules. Supports hot/cold context separation for caching.",
      "docs": "/docs/cx/01-overview/"
    },
    {
      "name": "flow",
      "title": "flow",
      "description": "The workflow orchestrator. Runs Markdown-based plans, manages agent lifecycles, and handles Git worktree isolation.",
      "docs": "/docs/flow/01-overview/"
    },
    {
      "name": "nav",
      "title": "nav",
      "description": "Keyboard-focused session manager for tmux. Provides 'Harpoon'-style rapid navigation across projects and visualizes Git status.",
      "screenshot": "/docs/overview/images/nav-overview-light.png",
      "screenshotDark": "/docs/overview/images/nav-overview-dark.png",
      "docs": "/docs/nav/01-overview/",
      "screenshotCrop": { "zoom": 1.5, "x": 50, "y": 20 }

    },
    {
      "name": "nb",
      "title": "nb",
      "description": "Workspace-aware notebook manager. Organizes notes, plans, and logs relative to specific repositories and branches.",
      "screenshot": "/docs/overview/images/nb-overview-light.png",
      "screenshotDark": "/docs/overview/images/nb-overview-dark.png",
      "screenshotCrop": { "zoom": 1.5, "x": 50, "y": 20 },
      "docs": "/docs/nb/01-overview/"
    },
    {
      "name": "hooks",
      "title": "hooks",
      "description": "Local observability for agent sessions. Tracks agent state (idle/running), sends notifications, and logs activity.",
      "docs": "/docs/hooks/01-overview/"
    },
    {
      "name": "grove.nvim",
      "title": "grove.nvim",
      "description": "Neovim plugin for managing context rules, running chats, and inspecting plans directly from the editor.",
      "docs": "/docs/grove.nvim/01-overview/"
    },
    {
      "name": "tend",
      "title": "tend",
      "description": "Scenario-based E2E testing library. Used to validate CLI tools and TUI applications within the ecosystem.",
      "docs": "/docs/tend/01-overview/"
    }
  ]
}

Auxiliary Tools

`docgen`

LLM-powered documentation generator that analyzes source code to create and maintain documentation.

`skills`

A package manager for installing agent capabilities (prompts and instructions) either system-wide or scoped to individual projects.

Why This Project Exists and Inspiration

Grove was inspired by the Neovim Plugin gp.nvim. I used this plugin heavily in 2024-2025. It made it easy to select large blocks of code to make precision edits and generate new code. I hacked together a context management approach using Neovim and Harpoon that enabled me to quickly mark files to be sent along with every gp.nvim API request. Over time, I found myself assembling larger lists of files using scripts. I would create a directory named nb inside each code project to store plans and notes. Creating a precise assortment of context comprised of plans, notes, and prompts generally led to predictable and controlled development. I was also a heavy user of tmux-sessionizer, a tool for jumping between projects quickly using key bindings.

When agents like Claude Code were released, I created new tools written in Go to solidify this approach, but the ideas remain largely the same.

gp.nvim -> Replaced by Claude Code and grovetools
Harpoon -> Replaced by grove’s cx tool and grove.nvim
Ad hoc nb dirs -> Replaced by grove’s nb tool
API-based planning process -> Replaced by the flow tool and grove-gemini
Sessionizer -> Replaced by grove’s nav

Grove is my personal approach to AI-assisted coding. It is designed for people who love plain text, Markdown, “local first”, Neovim, tmux, and tools like Obsidian. Hope you enjoy!

Getting Started

Install the Grove meta-CLI to get started. This single binary manages the installation and versions of all other tools in the ecosystem.

bash

curl -sSfL https://raw.githubusercontent.com/mattsolo1/grove-meta/main/scripts/install.sh | sh

plaintext

Grove

Guiding Design Principles

1. Explicit Context Engineering

Glob-Based Rules

Context Curation

Plan vs. Execute

Persistence

2. Plain Text, Markdown-Based Orchestration, and Logs

Structured Execution

Structured briefings

Persistence

Flexibility

3. Workspaces, Navigation, CLIs, Observability

Workspaces

Worktrees

Ecosystems

Keyboard-Based Navigation

Observability

CLIs

TUIs

Git

4. Repo-Paired Notebooks

Central Knowledge Base

Bidirectional Flow

Skills & Concepts

The Toolchain

Auxiliary Tools

`docgen`

`skills`

Why This Project Exists and Inspiration

Getting Started