Grove, an Agent Development Environment for Coding Agent Fleets

Overview

Grove is an agent development environment. It takes the coding agents a team already uses and runs them as a software factory, with a sandbox, an orchestration layer and observability around each one. Claude Code , Codex and OpenCode run unchanged inside it. Each task gets its own workspace and is tracked from ticket to trace.

Writing the code is no longer the hard part. A model writes a migration in minutes. The hard part is every decision around that. Where should this agent run. On a laptop, in a container, or on a shared machine. What input should it get, and in what form, so the output is the right thing. Which of twenty runs is stuck. Which one is waiting on a question. What did each of them run last night. One engineer with one agent answers those by looking. A team with a fleet cannot. Grove is where those decisions get made once. They live in a config file, a ticket and a trace instead of in every engineer’s head.

Workspace isolation and container runtimes

A workspace is one git worktree, one branch, one tmux session and one agent. Changes stay apart until someone reviews them. Pausing drops the worktree and keeps the branch. Killing deletes the branch only if Grove created it. A branch you made by hand survives. A session outlives a restart and reattaches.

Isolation on disk is not isolation of load. An agent can run in a sandboxed container built from the repository’s own .devcontainer/. Each gets its own files, services and ports, with CPU, memory and process limits per task. Egress runs through an allowlist. The same definition runs on a shared team machine or a serverless platform. The fleet scales with tasks, not laptops.

Grove creating a container workspace from the project's devcontainer, then Claude Code running inside it with a status line showing container CPU and memory — Creating a container workspace. The agent then runs under the container's own limits.

A committed .grove/config.json sets the agents , models and init scripts every workspace starts from. Each engineer overrides it locally. A workspace picks its own model without touching the shared file. New teammates inherit a working factory instead of assembling one.

Issue tracker integration and multi agent coordination

Assign an issue in Linear, GitHub or Gitea and Grove starts its workspace. The ticket is where the work was defined, so that is where progress returns. One comment on it is rewritten in place as the work moves. It carries the phase, the agent’s todo list, the latest commit and the pull request . A product manager follows delivery without learning a new tool. A comment of @grove with new instructions steers the agent from the same thread.

Grove's status comment on an issue with a phase table and a six step progress diagram from Scope to Handoff — The status comment on an issue, from the first phase to handoff.

The phase is a value the agent writes to a file, from scope to handoff. It is one of three axes Grove tracks. The workspace is running, paused or orphaned. The agent is working, waiting, blocked or idle. The task is in a phase. A workspace can be healthy while its agent sits on a human in the loop permission prompt. The fleet view sorts that one to the front. A push notification reaches your phone when an agent finishes a turn, emits a question or errors. The question’s options ride along. You can answer from the tray.

Grove terminal UI listing workspaces with phase counts and ticket references beside a live peek rail — The fleet from a terminal. Phases and tickets beside the selected agent's transcript.

Some work is too big for one agent. An orchestrator agent drives Grove through the Model Context Protocol . It launches worker agents as tool calls, reads their phases and steers them. Workers write to each other through a mailbox, so isolated workspaces still coordinate. A delivery receipt says a message reached a session and nothing more. Mail never widens what the recipient may do. One waiting on CI registers a watch and ends its turn. Grove sends it the result when the run finishes. No agent burns a terminal on a sleep loop.

Image annotation and diagram collaboration

Most of what goes wrong with an agent goes wrong in the brief. Grove lets you hand the agent a picture. Paste a screenshot or attach a file in either composer, up to 20 files per task. The agent receives a path, never bytes. It reads the file with its own tools. Press annotate on a staged image and an editor opens beside the transcript. Draw boxes, arrows and labels on the thing that is wrong. Send that instead of three paragraphs about it.

Grove's annotation editor open beside a transcript, with boxes and labels drawn on a staged photo — Annotating a staged image before it goes to the agent.

The same idea runs the other way. A person and an agent edit one draw.io file together. A UI mockup gets approved as a picture before any code exists. An architecture spec stays a diagram the agent reads and rewrites as XML. Grove validates every write and checks revisions. A stale edit is refused rather than forced over someone’s draft. Every diagram across every repository collects in a gallery, attributed to the workspace that produced it.

Grove transcript beside a draw.io architecture diagram the agent drew — A diagram the agent generated before writing the code, beside its transcript.

The web dashboard is where this happens. It follows headless sessions from any device. The transcript sits beside the branch, the diff and the linked tickets. A session catalog searches every recorded agent session on the host, including ones Grove did not launch. A usage view reads subscription windows, burn rate, tokens and cost from the transcripts on disk. It works offline and needs no invoice.

Grove web dashboard cycling through the launch composer, session catalog, a workspace transcript, image annotation, an agent drawn diagram, the usage audit and the fleet grid — Launching a task, the session catalog, a transcript beside its diff, annotation, a diagram and the usage audit.

Execution tracing and evaluation

An agent with a shell tool can do anything the shell can. Whoever runs a fleet of them has to answer, after the fact, what each one ran and why. Every agent turn becomes one OpenTelemetry trace in Langfuse . It holds the model requests, the tool calls and their results. Each span carries the workspace, model and token counts. The diff says what changed. The trace says what ran to get there.

A small local decision model, an LLM judge that returns one option and a probability instead of prose, labels each shell call with its purpose and a confidence score. People rate those labels from Grove with a thumbs up or down. The ratings calibrate them. A team sees the mix of what its agents do. It can alert on what they should never do. Review time goes to the calls with the lowest confidence scores.

Langfuse scores view beside an agent turn trace whose shell spans each carry a purpose label — Shell calls in one agent turn, each labelled with its purpose.