Every agent in its own copy, instantly

What you get

Every agent works in its own workspace with your current state: modified, staged and new files included. Your checkout, your HEAD and your Git index stay untouched. Many agents work in parallel on the same repository. Each one delivers a commit that you review and apply.

Before and after

You are working on serde and have three modified files and a new file PLAN.md, none of it committed. The task: A second agent should work with exactly this state, without writing into your checkout.

Without greppy

With Git you build the copy by hand: create a worktree, carry over the changes, find the new files and copy them.

$ git worktree add --detach ../agent-1
Preparing worktree (detached HEAD 7fc3b4c)
HEAD is now at 7fc3b4c Release 1.0.229
$ git diff HEAD | git -C ../agent-1 apply && git -C ../agent-1 status --short
 M README.md
 M serde/src/lib.rs
 M serde_core/src/private/size_hint.rs
$ git ls-files --others --exclude-standard
PLAN.md
$ cp PLAN.md ../agent-1/ && git -C ../agent-1 status --short
 M README.md
 M serde/src/lib.rs
 M serde_core/src/private/size_hint.rs
?? PLAN.md

You need four commands per agent before it starts. Its result lands as a branch in that worktree, which you merge and clean up yourself.

With greppy

greppy -p "TASK" creates the workspace itself. greppy index --agent-worktree creates the same workspace ahead of time and warms its index, so you see what the agent gets.

$ greppy index --agent-worktree
…
store mode: overlay (Base 61d1f6b54eac, reused)
…
indexed Delta generation 1: 4 changed/deleted paths, 9 private nodes (project: serde)
$ greppy workspace status
agent workspace ready (ordinary backend; provider inactive); 0 workspace(s), 378 chunks, 1575696 physical bytes

The workspace contains all four uncommitted paths and reuses the shared index; greppy indexes those four paths and nothing else.

	without greppy	with greppy
Commands until the copy is ready	4	0, `greppy -p` creates it
Uncommitted paths in the copy	4 of 4, carried over by hand	4 of 4, automatically
Index of the copy	none	shared Base, 4 paths in its own Delta
Result	branch in the worktree	commit under `refs/greppy/agent/<run-id>`

How it works

greppy keeps the state of your repository in a block store: files in blocks of up to 1 MiB, addressed by their BLAKE3 hash, with the bookkeeping in SQLite in WAL mode. Every workspace gets your commit plus everything you have modified, staged or newly created; ignored files stay out. greppy stores new content and nothing else: another workspace with the same state created 0 new blocks, and one with one additional modified file created 6 new blocks totaling 54,340 bytes. The workspace shares Git objects with your repository for reading; index, refs and new commits stay private. With an active provider (FSKit on macOS, FUSE3 on Linux, set up with greppy workspace setup), greppy mounts the workspace copy-on-write. Without a provider it creates private directories, with the same flow and the same result. At the end there is a commit under refs/greppy/agent/<run-id>. Its parent is your state including uncommitted changes, so the commit contains exactly the agent's work. Once the commit is saved, greppy removes the workspace.

The commands

Command	what it does
`greppy -p "TASK"`	starts the agent in its own workspace with your state; the result is a commit under `refs/greppy/agent/<run-id>`
`greppy index --agent-worktree`	creates the agent's workspace ahead of time and warms its index
`greppy workspace status`	workspaces, block store and provider at a glance
`greppy workspace setup`	sets up the copy-on-write provider
`git show refs/greppy/agent/<run-id>`	review the agent's commit
`greppy agent apply REF`	applies exactly the agent's changes; your Git index stays byte-identical
`git cherry-pick -n REF`	apply with plain Git