Why my coding agents moved from panes to threads
Four Pi agents in herdr at the desk. The work now lives in bb, where every agent has a thread and a diff.
At my desk I run four Pi agents in herdr, one per pane: a planner, a builder, a reviewer and a scout. It works well, and I still use it when I want a terminal in front of me. But since the middle of October most of my actual work has moved to bb, and herdr did not get worse. I really could not keep the state of four agents in my head any more.
bb made the same work feel calm for me.
— after three weeks of running bothFour panes were a good setup
The herdr setup is fairly simple. One workspace, four panes in a 2×2 grid, each pane running a Pi agent with a different job. The planner writes the approach, the builder implements it, the reviewer tries to reject it, and the scout goes looking for context before anyone writes code.
herdr is a terminal-native multiplexer. A workspace holds tabs, a tab holds panes, and every pane is a real terminal with its own shell or agent. It detects agent status, so the sidebar tells me who is idle, working, blocked or done, and I can wait for a pane to print a line or for an agent to finish. At the desk, with the work one screen wide, it is still the fastest thing I have.
Then the work got wider than one screen. Four agents in four panes means four streams of output, and only one of them is visible at a time. A full-screen agent redraws its own buffer, so when it finishes, the useful part has often scrolled past. I found myself clicking pane to pane, reading what was on screen, and rebuilding the state of the whole job in my head. That works for ten minutes. It does not work for a Tuesday.
To someone seeing it for the first time, it is a wall of terminals, and the important one is third from the left.
Four panes, four jobs
The grid is still on my desk. Each pane is a real terminal with its own Pi agent, and the sidebar tracks whether it is idle, working, blocked or done.
Top left
Planner
Turns the task into an approach and a sequence.
Top right
Builder
Implements the plan and runs the checks.
Bottom left
Reviewer
Tries to reject the result before I do.
Bottom right
Scout
Finds the context nobody asked for yet.
A pane is a view, not a record
Terminals are fine. The problem is that a pane is a view of a process. When the process ends, or the pane closes, or the TUI redraws, the view is gone, and the work might still be on disk but the reason for it is not there.
A terminal is built for the present tense. It shows me what is happening now, which is exactly what I want when I run a command. But an agent job is not a command. It has a brief, a conversation, a set of changes, a test result and a decision about whether to continue. The pane shows almost none of that, and the rest sits in my head.
When I run one agent, that is fine. When I run four, I become the orchestrator. I am the one who has to remember which builder is waiting on which planner, which review already failed, and which scout found the file nobody else looked at. I now realize that I was using my own memory as the orchestration layer, and that does not scale past three or four agents.
The other thing that bit me was review. In a pane, the diff is whatever the agent printed. If I want to see the actual change, I open another terminal, run git diff, and scroll, which is two extra windows for one decision. And if I come back the next morning, I have to reconstruct which pane was which.
| What I need | In a pane | In a thread |
|---|---|---|
| What is happening now | Live output, one pane at a time | Live output, the conversation and the diff |
| What survives a restart | The scrollback, if the pane is still open | The thread, until I archive it |
| How I review a change | Another terminal and git diff |
The diff in the same place |
| How I hand work over | Copy the prompt into another pane | Fork the thread or continue it with another provider |
| How I find it next week | Scrollback and memory | Search the thread list |
The thread is the unit of work
bb keeps the same agents and the same subscriptions. What changes is the container around them. A thread is one conversation with one agent, attached to one project and one environment.
The model is not complicated. A project maps to a repository. A thread is one agent conversation inside that project. An environment is where the thread runs, either the project checkout or a fresh Git worktree. Multiple threads can share an environment, which is useful when a review thread needs to read the same files as the builder. I wrote about the plan-build-review loop in Field Note 08, and I still use it. This note is about the place the loop runs in.
The nice thing is that the thread is durable. I can close the laptop, come back the next morning, and the conversation is still there. I can read what the agent tried, not just what it printed at the end. I can see the diff next to the conversation, open a terminal in the same environment, and check the PR without leaving the app. Nothing about the model changed. The conversation just stopped disappearing.
bb also runs the agents I already use. Claude Code, Codex, OpenCode, Hermes, Pi, Cursor, Grok, OMP. Each thread picks a provider, and the provider bills on the subscription I already pay for. I am not actually paying bb for tokens, and I am not locked into one model. I change models more often than I change projects, so that matters to me.
Three layers, one place
The hierarchy is small enough to hold in my head, which is the point. A project holds threads, and a thread runs in an environment.
01 · Project
The repository
One project per repo, with a source on each machine where it can run.
02 · Thread
The conversation
A title, a transcript, a diff, a status and a place in the sidebar.
03 · Environment
The workspace
The project checkout or a fresh Git worktree, shared by threads that need the same files.
04 · The view
One place to look
The conversation, the diff, a terminal and the PR status sit together.
What it looks like after twenty days
I started using bb in the middle of October. The local database now has 134 threads across six projects, and 78 of those threads are already archived. The number is a picture of how much agent work was previously living in terminal scrollback. I would not read it as productivity.
The six projects are a mix. One is this website, one is a CLI I am building, one is a review queue, and three are personal or experimental projects. Eighty of the 134 threads are in the Personal project, and not all of those are code. That is the point, I did not only move coding into bb. I moved the general “ask an agent to do a thing” work there too, because the thread model is useful for anything that needs a brief and a result.
Five providers did most of the work. Claude Code ran 55 threads, Hermes 25, Codex 24, Pi 16 and OpenCode 13. One OMP thread made up the rest. I did not plan that mix, it is what happened when a thread could pick whichever agent was good at the job, instead of me picking one terminal and staying in it.
Twenty days is a short sample, and the counts include personal work, so I would not draw a trend from them. But the shape is pretty clear. The work accumulates in one place, and I can see it.
| Provider | Threads |
|---|---|
| Claude Code | 55 |
| Hermes | 25 |
| Codex | 24 |
| Pi | 16 |
| OpenCode | 13 |
| OMP | 1 |
| Total | 134 |
The parts I did not expect
Two things changed my mind more than the thread list. The first was remote access. The second was that bb is malleable enough that I could build the features I wanted, inside the tool I was using.
The connect plugin gives this bb a URL I can open from another device. That sounds small, but it changes the shape of the day. On my commute I can read a thread, answer a question, or start the next task, and the agent is running on the machine at home, not on my phone. I am not actually trying to run a coding agent on a phone. I am checking on one.
The plugin system is the part I did not expect to use. I ended up building two. Plan Toggle lets me tap Control to switch the composer between Build and Plan mode, with an optional separate planning model. Voice Shortcut lets me hold a key, talk, and release to send, or double-tap to put the transcription into a draft without sending it. Both are small. Both are things I really wanted every day. I built them with an agent inside bb, which is a strange loop, and I enjoyed it.
I am not saying everyone needs to build plugins. I am saying the tool did not stop me when I wanted to. The fact that it can be shaped around one person's habits is the difference between a product and a workbench. bb is MIT licensed and local-first, so I can shape it around the way I already work.
Two small things I wanted every day
Both are public, and both came out of using bb long enough to know what was missing. The tool was open enough to let me add it.
Plan Toggle
Control switches modes
Tap Control to move the composer between Build and Plan, with an optional separate planning model. Source on GitHub.
Voice Shortcut
Hold to talk, release to send
Double-tap to put the transcription into a draft instead of sending it. Source on GitHub.
It costs something, and herdr is still better at some things
bb is free and open source, so the licence is not the cost. The cost is a server, an app and a set of provider bridges, and that shows up in memory, setup and sharp edges.
When I measured it, bb was using about 650 MB PSS across 11 processes, with the server at around 405 MB. That is not huge on a 15 GiB machine, but it is not nothing. herdr is a terminal multiplexer, so it is much lighter and does not need a server.
The setup took longer than I expected. A project needs a source on the machine where the thread runs, and my Mac paths did not exist on the Linux box. One project pointed at a folder that was not a Git repository, so worktree isolation did not apply. I had to fix the sources before any of the orchestration was real. That is not a bb flaw, but it is the kind of thing that makes a tool feel worse than it is on day one.
The sharp edges are worth knowing. A fresh worktree gets tracked files only, so .env and node_modules are missing unless you add a .worktreeinclude or a setup hook. Archiving a thread can remove its worktree, including uncommitted changes, so commit before you archive. The local HTTP API is unauthenticated by design, which is fine on loopback and a bad idea anywhere else. And the Linux and Windows desktop builds are still labelled alpha.
None of that makes herdr worse. If I want a shell, a log tail, a quick test run, or a script over SSH, herdr is still the better tool. It is keyboard-first, it is fast, and it does not need a server. The four-pane Pi team is still a good way to work when I am sitting in front of it. I think the honest split is this. herdr is where I drive a terminal. bb is where the work lives when I am not driving.
| Job | Use | Why |
|---|---|---|
| A shell command or a log tail | herdr | It is a terminal, and it is already open. |
| Four agents at the desk, all visible | herdr | The 2×2 grid is still the clearest way to watch them. |
| Work I need to come back to tomorrow | bb | The thread, the diff and the conversation stay in one place. |
| Reviewing a change with the conversation next to it | bb | No second window, and no reconstructed context. |
| Starting a task from my commute | bb | Remote access through getbb.app, with the agent running at home. |
| Running agents on three machines | bb, with setup | It works once each machine has a project source and a provider that is signed in. |
A workbench is judged by what survives the session
I still think herdr is excellent at what it does. I am not replacing it. The four-pane grid is still on my desk, and the Pi team still runs there when I want to watch a build. But the centre of gravity moved, and it moved because the thread gave the work a memory.
If you are starting with agents, my advice is boring. Use one agent in one terminal until it stops fitting. Then use a workbench. Put one project in it, pick one provider, and run one real task from start to finish. The moment you come back the next morning and the conversation is still there, you will know whether this way of working is for you.
Let's see how long the split holds.
— end —