Vol. 01 · No. 09
— Field Notes —
November 2026
A Field Note on Agentic Software Engineering

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 both
01 · The desk setup

Four 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.

herdr · one workspace

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.

Figure 1 One workspace, four agents, one screen. The layout is quick to read when I am sitting in front of it. The trouble starts when the work outlasts the screen.
02 · Where panes stop

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
Figure 2 The pane is a view. The thread is a record. That difference only matters when the work has to survive the session, which is most of the work I care about now.
03 · What a thread changes

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.

bb · the model

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.

Figure 3 The thread sits between the repo and the machine. That is where the brief, the changes and the review end up in the same place.
04 · Twenty days in numbers

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 Code55
Hermes25
Codex24
Pi16
OpenCode13
OMP1
Total134
Figure 4 The counts are from the local bb database on 2 November 2026. The mix is the point, not the ranking. A thread could pick whichever agent was good at the job.
05 · The parts I did not expect

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.

bb plugins · built here

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.

Figure 5 Small features, but they change the daily feel. Plan Toggle removes a mode switch I used to do in my head. Voice Shortcut removes the keyboard from the first draft.
06 · What it costs

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.
Figure 6 The split is by job, not by loyalty. herdr is still the better terminal. bb is the better place for work that has to survive the session.
Closing observation

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 —

Why my coding agents moved from panes to threads · A Field Note Set in Shadows Into Light Two & Cause

← Back to all posts