Chats and terminals

Every chat in Grove is a real terminal. The agent CLI — Claude Code, Codex, or opencode — runs as an actual interactive process, so you get the full surface of the agent you chose: slash commands, multi-line edits, real scrollback. There is no watered-down "chat bubble" renderer; a chat and an agent terminal are the same thing.

Per-workspace chats

A workspace can hold any number of chats, each with its own agent. Start one from the workspace's hover card (one button per agent), from Cmd+N, or from the new-tab picker. Each chat's transcript lives with the workspace — conversations are part of the work, not app state.

A chat opens as a floating popover by default. Expand it into a full editor tab when you want more room, split it into its own pane, or minimize it to the chat bar at the bottom of the window. None of those moves interrupt the agent — the session survives every transition.

Cmd+1–Cmd+9 jump straight to your chats; pressing the same number again tucks the chat away. The chat bar also has a focus mode that fills the editor area with a grid of every open chat — the fleet view for a heavy agent day.

Agent providers

Grove launches whichever agent a chat is configured for — Claude Code (the default), Codex, or opencode — and each resumes its own session across close and reopen, so a conversation picks up where it left off. Set your default in Settings → Agents, or pick a different agent per chat.

Agents run exactly as they would in your own terminal: they read their instruction file (CLAUDE.md / AGENTS.md) from the working directory, plus a short workspace preamble Grove provides so they know about comments and their Grove tools. You can customize or disable that preamble in Settings → Agents.

Chats name themselves

The chat pill follows the agent's terminal title — as the agent moves between subtasks, the label updates to whatever it's currently working on. The pill also tints when a turn finishes while you're focused elsewhere, and badges the workspace's open-comment count.

Plans land in your notes

When an agent proposes a plan — Claude Code's plan mode, or Codex's plan tool — Grove captures it as a plan.md note in the workspace and opens it in the editor, before you approve it. You review the plan as a real document, not scrollback; revised plans are kept alongside (plan-2.md, …) so the iteration history survives.

Resuming conversations

Closing and reopening a chat resumes the agent's own session — the conversation picks up where it left off. A chat's resume picker also lists the agent's existing sessions for that directory, including ones you started outside Grove, so a conversation that began in your terminal can continue inside it.

The project chat

Not everything belongs to a workspace. A project chat runs at the repo root, has the full MCP tool surface, and can create workspaces — useful as a dispatcher: describe the work, let the agent split it into workspaces with their own worktrees.

Sending code to a chat

Select code in the editor and use the selection toolbar to send it to a chat as pinned context, or drag files from the tree (or Finder) straight into any terminal. Agents receive real paths, not screenshots.

Agents talking to each other

Grove already runs a lot of agents at once — one per chat, each in its own workspace and worktree. They can also address each other, which turns that grid of panes into something an orchestrating agent can drive: read the roster, hand work to a peer, check back on it.

Tool	What it does
`chat_list`	The roster — every chat, the workspace it's in, the agent running it, and whether it's live right now.
`chat_send`	Put a message in another chat's prompt, exactly as if it had been typed there. Opens and starts the chat if it isn't running.
`chat_read`	Read what's on a running chat's screen.

The project chat is the natural dispatcher — it can already create workspaces, and now it can start a chat in one and hand it the brief.

You watch all of it happen. A message from one agent lands in a real chat you can read, interrupt, or take over; nothing runs in a hidden side channel. That's the difference from a subagent spawned inside someone else's session — these peers are durable, visible, and keep their own worktree and history across restarts.

Two things to know before building on it:

chat_send returns when the message reaches the peer's prompt, not when the peer answers. There is no reply channel. If you want something back, say so in the message — have the peer write its result to a note or leave a comment, then read that.
chat_read shows the screen, not the history. Agent CLIs paint a full-screen interface, which by its nature keeps no scrollback, so you get what's currently visible — and you get the rendered interface, spinners and boxes included, not a clean transcript. It's right for "is it done, what's it showing, is it stuck on a permission prompt" and wrong for anything you need to parse. For that, again: have the peer write it down.

The same three are available from the shell as grove chat.

Terminals

Grove also hosts plain terminals running your real shell — Cmd+T opens one, and terminals live as tabs right alongside files and chats. They survive workspace switches: the process and scrollback keep running, and expanding a minimized terminal puts you exactly where you left off. Terminal tabs can even be dragged out into a separate window without losing the running process.

Links in terminal output are live: Cmd-click a URL (a localhost dev server, an HTML test report) to open it in the embedded browser, or a file path to open it in the editor.

Scrolling that doesn't fight you

Output auto-follows while you're at the bottom. Scroll up to read something and Grove leaves the viewport alone; scroll back down (or type) and follow re-arms. This sounds obvious — it's surprisingly hard to get right in a terminal, and it's handled.