Glass Atlas

The person I learned basically everything about agentic coding from used to run two terminal windows with three or four panes in each, all of them busy. That was the picture in my head of what doing this seriously looked like. Lately they've gone app-only. No panes, no terminal, just the desktop apps.

That genuinely shocked me, and it's the thing that got me paying attention to a shift I'd been half-noticing everywhere else. What I can tell you is what I see: the people around me who want one consolidated platform lean hard toward the apps, and the companies building these tools are leaning even harder into giving them one.

I still work in the terminal. I also think I'm going to end up switching, and I think the reason has less to do with the harness than with where the models are heading.

What the apps are selling

Look at the lineup right now. OpenAI has the Codex app. Cursor has been pushing further than anyone on app design and capability, and at this point it feels like the one setting the pace. OpenCode started life as a terminal TUI and grew a desktop app. Even community projects like Theo's T3 Code are building GUI shells around coding agents. Big lab, well-funded startup, open-source side project, and they're all heading the same direction.

And as far as I know, the reason is simple. The apps can simply do it all.

They have:

Multimodal input and output, which a terminal TUI just doesn't do
Subagent delegation that's actually intuitive to set up and watch
Dedicated machines per agent, like Cursor giving each agent or session its own VM
Content creation tools for images, video, and other media
Proper views of diffs and git branches instead of scrolling back through output
Automated workflows and schedules you configure right from the app

If you want one place that does everything, the apps are built for you, and they're getting better at it fast.

Why I haven't moved

My setup is pretty simple in comparison. Often I am working in one Windows Terminal window, split into two or three panes, sometimes four, across both WSL and the Windows side. Sometimes I'll use tmux instead, or my own terminal, cloo. The panes are mostly running the Claude Code CLI and the Codex CLI, with Codex occasionally routed through OpenCode.

The way I actually use those panes is where the terminal earns its keep. With two or more agents going, at least one of them is usually looping on its own, working through tasks in a [[the-loop-is-the-skill|Ralph loop]]. The other is either planning with me or looping on its own set of tasks. Once everything's assigned, I can look away. I can leave it alone for a good while and come back to finished work.

The terminal's best feature is that it doesn't ask for my attention.

Spinning something up takes seconds, there's no ceremony, and the interface is trimmed down to exactly what I need, which is a prompt and a stream of output. Multipaning is trivial because the terminal already does it and has for decades.

The apps lose me on two fronts right now.

They're heavy. I've watched the processing load when launching and running them, and it's noticeably more than a handful of CLI sessions. For tools whose whole job is to wait on a remote model, that's a lot of local overhead.

Chats are stuck in their tabs. As far as I know, each conversation still lives in its own tab, and there isn't a great multipane view inside the apps. That's exactly the thing I lean on most. Watching three agents side by side is the default in a terminal and awkward everywhere else.

Here's how it shakes out for me today:

	Terminal	Apps
Spin-up speed	Seconds	Slower, heavier
Side-by-side agents	Native panes	Mostly one chat per tab
Resource cost	Light	Noticeably heavy
Multimodal	Text only	Images, video, media
Diffs and branches	Whatever you wire up yourself	Built-in views
Per-agent machines	Bring your own	Offered (Cursor VMs)
Schedules and automations	Scripts and cron	Configured in-app

Looking at that table, you can see my problem. The top three rows are the ones that matter for how I work today. The bottom four are the ones that matter for where this is all going.

The models are shifting too

This is the half that actually changes my mind, and it has nothing to do with app features.

I judge new model releases mostly against DeepSWE. It isn't the source of truth, and it has its own flaws like every benchmark does, but it's consistent with itself, which makes it good for comparing one release to the next. Watching the trend there, the jump in mode capability between releases keeps getting smaller. Add in the fact that there should theoretically be a ceiling somewhere, and my read is that raw coding capability is starting to plateau.

So what do you do as a lab when the coding curve flattens? You specialize. Something like GPT-6 Astra is the clearest example I've seen: it was advertised and tested on things like working directly in Blender and making videos from scratch. Content generation, deeper multimodal interaction, and models marketed as experts in a specific domain instead of as a better autocomplete for your repo.

I think we're watching a new transition in the AI space: the models are becoming specialists, and the apps are being built as the packaging that ships with them.

Same transition, twice

Put those two shifts next to each other and they start looking like one shift.

A terminal is a great harness for a model whose output is code and text. That's what it's good at, and it's why my setup works. But when the model's output is a rendered video, a Blender scene, a batch of generated images, or a swarm of agents each running on its own machine, a text stream can't show you what happened. You need a surface that can display media, visualize the branches, and let you poke at what each agent is doing.

That surface is the app. Once you see it that way, the feature pile stops looking random: the labs are building the harness their next generation of models needs.

It's also something I've been circling from the other direction. I've already been sketching out [[building-myself-a-persistent-agent-on-paper-for-now|an always-on agent on a rented box]], because I want an agent that runs without me opening a laptop. Cursor handing every agent its own dedicated VM is basically that idea turned into a product feature. The apps are productizing the exact things terminal people have been duct-taping together.

What would actually get me to switch

I'm not switching today, but I know what would do it:

Multipaning that's actually intuitive in the app, so I don't lose the side-by-side view I live in
A real reason to use the bundled features: per-agent VMs, branching, and some kind of visualization of an agent swarm that's better than squinting at panes
Work that needs multimodal visibility, where I'm generating or reviewing something a terminal simply can't render

The first one is on the vendors. The other two are on me, and honestly they're just a matter of time. The day my work stops being "loop through these coding tasks" and starts being "have these specialist models build this thing across three mediums," the terminal stops being the simple option and becomes the limited one.

So yeah, I'm still in the terminal. I just think the holdouts, me included, are going to follow the same path as the person who taught me all this. We'll just get there a little later, once we have a reason to.