I Tried to Leave the Terminal Eight Times. The Ninth Finally Stuck

Ten months of running my agent from a black window, eight interfaces that almost worked, and the open source agentic IDE that ended the hunt this week.

In October last year Claude Code pulled me into the terminal, and I basically lived there until this week. Ten months of running my agent Wiz, spinning up projects, building and killing ideas, all from a black window with a blinking cursor. I felt good there. I had zero problem with it.

And the whole time, quietly, I was hunting for something better.

Because here is the thing nobody tells you when you go all in on terminal agents: the terminal is great for so many things and it is still not built for this. It was designed for one human typing one command at a time. The agentic era is many sessions, long-running work, things happening while you are not looking. You can duct-tape tmux panes and clever multiplexers on top of it, and I did, but you are patching a 50-year-old interaction model. Even Theo Browne, a lifelong tmux power user, spent an August podcast arguing the terminal is structurally wrong for managing parallel agents. I got to the same place the slow way: by trying everything else first.

The real problem: two worlds

My struggle was never “terminal bad”. It was that I lived in two worlds that refused to merge. World one: the AI world, sessions and conversations and work happening in the terminal. World two: the human world, tasks and projects in interfaces that are readable and easy to navigate.

When you already work in Basecamp or TickTick or Jira, you grow an attachment to that environment and it holds your life fine. But an environment built specifically for working with agents is a different animal, and honestly, I think I started hunting before the good concepts existed. So I kept going back and forth, building and destroying, migrating one way and then the other. I have written about why I destroy almost everything I build, and this hunt was that pattern at full speed. And to be real about it: going from idea to idea is now so cheap and fast that none of these migrations felt like a big deal. That cheapness is what made the whole search possible.

Attempt 1: build it myself

February. I built my own boards app for Wiz, native to how I wanted macOS software to feel. It worked. It was genuinely usable. I wrote the whole story of that build and its death, but the short version: software with exactly one user has a maintenance tax that never stops. Every time I shipped a new feature or workflow somewhere else in my system, a little voice said “okay, now remember to update the app too”. You might say “give that to your agent”, and sure, I did. But the remembering still ran on my brain. That is exactly the kind of background load I build systems to remove, not add.

Attempts 2 and 3: Fizzy, then Basecamp

Then I grabbed tools I either knew well or could crack open. Fizzy, the open source kanban app from the Basecamp family, was honestly great. Lightweight, easy, and because it was open source it felt like magic to mold it into my needs. Remember that word, mold. It comes back at the end.

Fizzy was good but I needed something more project-shaped, so I moved the operation into Basecamp itself. Also good. But both shared one failure mode: if you do not live in the tool daily, you drift away from it. My agent kept working on things, and the board stopped reflecting reality, because the surface where work happened and the surface where work was tracked were still two different places. Things were happening without me knowing they were happening. A board you have to remember to visit is a board that lies.

Attempt 4: TickTick, the best of the detached era

So I migrated to TickTick, and credit where due: it is one of the best integrations I ever wired up. Simple API, easy to attach an agent to, easy to track. I still use it today. I even bridged the two worlds a little: I could comment on a task and my agent would pick it up, and because my memory system carried the context, the terminal session remembered everything we discussed on the task surface. I am genuinely proud of that plumbing.

And it still felt detached. I was talking and working in the terminal, and my tasks lived somewhere else. Two worlds, now with a bridge between them. A bridge is better than a wall, but you still feel the border crossing every single time.

Attempt 5: a smarter terminal

Next angle: stop bridging worlds and upgrade world one instead. I started using cmux, a native macOS terminal built on Ghostty’s rendering engine, designed exactly for running multiple coding agents side by side with a project panel on the left. The concept is fantastic and I used it a lot. If you live in the terminal with agents, look at it.

But after a few weeks the honest verdict was: it is a smart way to use the terminal, and it is still the terminal, with all the advantages and all the disadvantages. A middle ground, not an answer.

Attempts 6, 7, 8: the app era

What I actually wanted was closer to a Cursor-like experience, that agent view where the conversation and the work share one surface. So I tried the apps.

T3 Code. Theo’s open source desktop app for running official agent CLIs in parallel, started this year. Conceptually this is almost exactly what I had in my head, and so many of its ideas are right. It is also alpha, and Theo is very clear about that. It crashed on me, it did weird things, and I want my daily driver stable. Theo will get it there; I check back every few weeks.

Claude Code inside the Claude desktop app. This one is funny, because I had dismissed it before and started wondering whether I had simply been wrong. So I gave it a real week. The shape is right: a UI over the agent, sessions visible, no black window. But it is not what I was looking for, and you are locked to one model family, which matters to me since I stopped being a one-model person a long time ago.

The Codex app. Tried it around two months back and liked it more than I expected. This was the first real signal, because when I had a ChatGPT Pro subscription, I noticed most of my work drifted into the Codex app instead of the CLI without me deciding anything. When your hands vote against your setup, listen to your hands. I have compared these two stacks in real usage before, but this was a different lesson: the drift itself was the data.

Attempt 9: bb

And then, recently and honestly by accident, I stumbled on bb. The README calls it “an agentic IDE that builds itself”, and that sentence is doing real work. Your agent runs in threads you can watch live, redirect mid-flight, or hand off to other agents. Desktop app, web app, CLI, and HTTP API are all first-class surfaces onto the same thing. And because it is open source (MIT, and yes, another alpha-grade project, I know what I said about stability), the tool itself is something my agent can extend while running inside it.

This is the part that sold me completely. The two worlds finally collapsed into one. The place where I talk to my agent, the place where the work happens, and the place where I can see and steer it are the same place. Everything I was trying to hand-build in February exists here, without the one-user maintenance tax, because a community carries it.

What bb actually gets right

“Sold” is easy to say, so let me show the goods, because the good stuff here is not one killer feature. It is a handful of concepts fused into the architecture.

Child threads you can see and steer. My agent spawns sub-threads for parallel work, and every one of them is visible on my screen. In the terminal era, subagents disappeared into a black box and I got a summary at the end. Here I sometimes step into a specific child thread mid-flight and hand it extra context, because I know something about that one slice of the work that the parent agent does not. Steering the workers, not just the manager, was never possible before.

Threads talk to each other. And it goes beyond parent and child. A thread can spawn a sibling, drop a message into any other thread, look up what else is running, even dig through the archive to see what an older thread was working on. That turns threads from isolated sessions into something closer to a team that shares a hallway. I have barely scratched what this unlocks, and I can already feel the potential.

Showing me things is built in. Months ago, when my agent finished a report or an HTML file, delivering it to me was its own engineering problem: where does the file go, how do I open it from my MacBook when the agent wrote it on the Mini. I built plumbing for that, and rebuilt it, more than once. In bb it is a solved problem I never think about: the agent shows me the file, rendered, even from a remote machine. A whole category of glue code I maintained for months just stopped existing.

Machines connect like it is nothing. My agent lives on a Mac Mini; I work from a MacBook. The old way was SSH, and everybody who has done that knows the tax: internet drops, you close the lid, the session is gone. tmux and cmux patch that, and a patched terminal is exactly what I spent this whole post trying to leave. In bb the connection is just there, same UX on every machine, phone included, different projects running on different boxes. Working across machines stopped being a skill and became a tab.

Bring your own subscriptions. I plug in Anthropic, OpenAI, and opencode, and work with all of them in one place. After the Claude app’s one-family lock, this alone feels like magic. My multi-model habit finally has a home instead of a workaround.

Automations and plugins. It has scheduled automations built in, and an extension system where you write your own plugins. Which means “I wish it did X” is a prompt to my agent, not a feature request to a vendor. This is the moldability point made concrete: the tool my agent runs inside is a tool my agent can extend.

Tasks live where the work lives. This one closes the loop on the whole post. bb has tasks fused in, so the entire detached-board saga from the first half, the drifting Fizzy board, the Basecamp I forgot to visit, the TickTick bridge, dissolves. My agent already had a memory system and task plumbing that worked, but this is a highway where I had hand-built bridges. Agents read and update tasks natively, and I can open the tasks tab and delegate one straight to an agent. The board cannot lie anymore, because the board is the workspace.

It feels like the thing I was too early for in spring finally showed up. I would have loved to discover it months ago. It did not exist months ago. That is what being early to a category feels like from the inside: you are not wrong, you are waiting.

The pattern underneath: moldable software wins the agentic era

Step back and there is one thread through this whole hunt. Everything that almost worked was closed or mine alone. The thing that stuck is open and moldable.

I am a huge fan of DHH and the whole 37signals way of building, and DHH is currently pushing Omarchy, his own Linux distro. I have been on macOS for something like 20 years, and I can hardly believe I am typing this, but I have started seriously considering giving Linux a real shot. macOS never failed me. The agentic era just changes what you want from software: when an agent can reshape your tools while you sleep, software you can mold beats software that arrives finished. Linux is the extreme version of that idea. bb is the same idea applied to the agent workspace. Build your own things was always my instinct; the correction this year taught me is subtler: you do not need to build the whole tool, you need the right to reshape it.

And if bb dies like half the things in this post died, that is fine too. Migration is cheap now, and I know the shape I am looking for: threads I can see, a tool my agent can extend, a community carrying the weight. This week, for the first time in ten months, my agent’s work is something I watch instead of something I check on. That is the whole difference, and it took nine tries to name it.

---

If you are wiring up your own agent and want the shortcuts I learned the hard way, the playbooks in the Wiz store cover the setups that survived this whole journey.

I write one of these every week: real experiments with AI agents, including the dead ends. If you are hunting for your own agent surface, subscribe and skip a few of my wrong turns.