Before Nodal: a tool called ToolTab#
The story begins with ToolTab v1, a Windows clipboard workspace written in WPF and .NET 10. It grew from an editable clipboard history into a tabbed suite of small tools, then into a notification center and an activity monitor that could detect Codex and Claude Code sessions running in Warp, Windows Terminal, VS Code, Cursor and the desktop apps. By late summer it had hundreds of tests, a theme library and a feature the owner liked more than any other: the Beeper, a small window that told the owner when an agent needed attention. A companion dictation prototype started on 8 August 2026 and was rewritten as a native WPF app four days later, becoming NodalVoice.
v1 also taught the limits of watching from outside. It could read a session’s status from process and window evidence, but reliable prompt delivery needs a controllable terminal or session endpoint, so the plan for the next version flipped: own the sessions instead of observing them.
The timeline#
- A planning session on v1 concludes that to control agent sessions reliably the app should launch and own them.
- The first commit of ToolTabv2 contains documentation only. Two independent initial plans (one from Claude, one from Codex) frame what must be decided. By the end of the day the Page 1 review pass and the Page 2 prototype planning packet exist, and the first set of numbered decisions is recorded. Agent Mode and Tab Mode are confirmed as the only two core surfaces; a third Workspace Mode is explicitly declined.
- A 13-group UI and UX plan is finished, the project docs are compressed for the builder agents, and the technical plan is approved: direct Codex app-server first, an in-process Agent Simulator and a staged multi-terminal capacity test.
- The shell and layout feasibility gate passes. The application source is renamed to Nodal. Window chrome and tray lifecycle are decided.
- Real Tab Mode terminals run inside the final sandboxed seam. Then real Codex Agent Mode works end to end: a real session starts, streams an answer, reports state and cancels. All 17 rows of the provider test matrix pass, and the credential boundary is measured acting. The owner tests it and says it is barely working because the model cannot be chosen; the model picker and five permission modes follow immediately.
- An audit of the shell compares four palette directions and sets the direction for the default dark theme, with measured contrast ratios.
- Nodal is proven on Linux from one codebase, with an AppImage that builds and runs. A Cordis and SpaceWatcher lab proves the plugin isolation model and is merged with its own test application.
- Eight ideas from the owner’s idea board are turned into five implementation packages. See IdeaBoard.
- A new decision authorizes the Claude, Ollama and IdeaBoard program. Session archiving, steer and queue arrive in Agent Mode the same day.
- Provider management, artifacts and previews, a read-only Review tab, completed-turn disclosure, close-source settings and shutdown progress land. The Claude lane builds the Claude Code adapter (stages C0 to C5) and the Ollama runtime (O0 to O4). The ChatGPT lane builds the panel terminal, the shared browser, the file explorer and the mode and status line.
- Version 0.2.0 is cut for invited testers, installed on the owner’s machine and published as a pre-release. The main branch is intentionally left untouched until testing passes. Livestreaming the work on The Late Build follows in October.
- Worktrees and branches are tidied and the records brought up to date.
Numbers that frame it#
- 256commits in the main repository by 3 October 2026
- 27distinct days with commits, starting 16 August
- 140+numbered decisions in the ledger
- 1,673unit tests passing in the last recorded gate, with one intentional skip
- 3providers: Codex, Claude Code, Ollama
- 2operating systems in the codebase: Windows and Linux
The big decisions, in order#
Looking back, a handful of decisions shaped everything. They are recorded in the decision ledger, and each had alternatives weighed.
- Two modes only. Agent Mode and Tab Mode. A third mode was declined. This kept the first proof small.
- Electron and TypeScript. Chosen over WPF, WinUI, Avalonia and Tauri for plugins, one rendering technology and reach. See the architecture page.
- Direct Codex app-server first. The Agent Client Protocol was reviewed as an optional later adapter and not allowed to replace it.
- Embedded terminals with ownership. xterm.js, node-pty and identity-checked process ownership.
- No credential store. Measured, not assumed. See security.
- Cordis for wiring, Electron for isolation. Corrected before it closed so no one expected a sandbox from a composition framework.
- Close with the app, for now. Close-to-tray was deferred because its lifecycle questions are still open.
- A real simulator, kept honest. Fake evidence never upgrades a real claim.
What went wrong, on the record#
A history that lists only wins is not a history. The ledger and the session log record these:
- A hand test found that closing or dragging one terminal window killed the shells of others, because windows were identified by position. The layout was rebuilt as a flat list keyed by identity.
- A native crash in the terminal library, caused by two shells ending at once, was traced to an unsynchronized list. It is mitigated and still open, because the repair belongs upstream.
- The session list showed 210 terminal windows as conversations until a migration separated them.
- An early live probe captured a real email address in a transcript. Masking was moved inside the redactor and the transcript replaced.
- A main-process error dialog reported by the owner, caused by an asynchronous pipe failure, was fixed with guards and three forced-error tests.
- The owner’s first impression of Agent Mode was that it barely worked. That was fair, and it was fixed.
The people and agents#
The human at the center is the product owner, referred to throughout the records simply as the Human Product Owner. Public handles are on the about page. The agents are Claude models, ChatGPT and Codex models and, in the Plugin Lab and provider work, sub-agents that handle narrow tasks. The roles and rules are described on how it’s built.
What each phase taught#
The timeline above is easier to read as a series of lessons. Planning taught the value of disagreement. Having a different model review each plan surfaced assumptions that the author could not see, and the decision ledger made every reversal visible instead of silent. The first real terminals taught that identity beats position. The layout bug that killed the wrong shells led directly to the keyed-window design and the process-ownership rules that now protect every terminal. Real Codex taught that measuring beats reading. Letting the Codex binary describe its own protocol, instead of transcribing documentation, turned a guess about credentials into a measured fact. Linux taught that portability finds bugs. Defects that had been hidden by Windows timing came to light on a second platform and were fixed on both. The plugin lab taught honesty about limits. Writing down that declared capabilities are not operating-system restrictions prevented a false sense of safety. The provider program taught the cost of parallel work. Two lanes, separate working copies per package and a coordination board made it possible for two sets of agents to add a dozen packages in under two weeks without trampling each other. And the beta taught the benefit of stopping. Releasing 0.2.0 to testers, with the main branch untouched, turned an endless feature list into a short list of things people actually bump into.
The common thread is that most of the improvements came from running the software and writing down what happened, rather than from writing more specification. It is also why the history is long on details and short on adjectives.
Reading the records yourself#
Everything above can be checked. The decision ledger, session log and evidence folders record dates, commands and results, and the numbers on this page come from them. When a statement here is a summary, the underlying record says more, including what was uncertain at the time. If you find a place where this page and a record disagree, trust the record and tell the community on Discord so the page can be corrected.
What happens next#
After testing, the integration branch merges into the main branch, side chat is built and a private repository follows. The roadmap tracks the rest. If you want to see development happen rather than read about it, the stream is where it happens: the livestream page on The Late Build.