The Terminal Just Evolved for the First Time in 50 Years. Not for Developers. For Their Agents.
Ghostty. cmux. A browser in a pane. I've been using terminals since edlin. This time the shift is structural, and there's no going back.
When Karen from Accounting starts talking about terminal emulators, something has already shifted.
She told me she "just opened a black window, typed something, and my expense report sorted itself." She meant Claude Code. Running in a terminal. She called it "the black window." I had no response to that.
Jarred Sumner (the person building Claude Code's infrastructure at Anthropic) just ran a demo in Ghostty. One command. The bun.sh website renders in full: HTML, CSS, images, animations. Not a screenshot. Not an embed. The browser, inside the pane. Mitchell Hashimoto, Ghostty's creator: "Alright, this is the kick in the ass I need." Boris Cherny, at Anthropic: "wtf." The thread lit up.
I've been using terminals since edlin (the DOS line editor, 1987, no cursor, you typed line numbers to navigate). Almost forty years of terminals. And in the last 18 months, more structural change than in the previous fifty. Something is pulling all of it in the same direction. And it's not us.
TL;DR: The terminal just became the most important piece of infrastructure in AI development. Not because developers chose it. Because agents had no choice.
Ghostty Hit 4k Likes on a Patch Release. Then cmux Happened.
A Ghostty patch release. Scrollback search. Native scrollbars. Performance improvements. 2,858 commits, 180 contributors, 46.7k GitHub stars (enough to overtake Hyper in under 15 months, despite Hyper having years of head start).
That doesn't happen because the features are groundbreaking. It happens because developers have been waiting for someone to care about terminal fundamentals the way Mitchell Hashimoto cares about them.
But the interesting part isn't Ghostty. Point is what it created.
cmux is built on libghostty. WebKit native: browser rendering inside panes, no subprocess, no external dependency. CLI Unix socket so agents control panes programmatically. Not a plugin. Architecture designed for something the terminal has never had: agents that need to see what they build, in context, without leaving the session.
I've spent time with Warp, Zed, and cmux. Warp turned a terminal into a SaaS product: mandatory login, opaque request counting, $15/month to use a black window. Power users burned through their daily quota in under an hour without understanding why. You're not paying for a better terminal. You're paying for AI compute with a terminal bolted on.
Zed's terminal is basically minimal VS Code with a shell. Clean, fast, no opinion.
cmux is the only one that understood the actual problem: the browser needs to be inside the session, not adjacent to it.
It's also the beginning of the adventure. You need allowUnixSockets for the cmux socket (conscious sandbox tradeoff, not a full disable). The down arrow breaks after opening a browser tab. It's in the TODO. Agents don't need arrow keys. Humans do. These are big, ugly, alpha-grade bugs. Might change fast.
Anthropic just shipped /voice in Claude Code. Type it in the terminal, hold Spacebar, talk. Your prompt appears in real time. No separate app. No browser tab. The input layer for your AI coding agent is now text and voice, inside the terminal. (You can stop alt-tabbing now.)
The person building Claude Code's infrastructure and the person who wrote Ghostty ended up in the same ecosystem within 18 months. Zero coincidence.
Four Things the Terminal Can't Do (That Agents Need Right Now)
So why now? Not because developers got tired of tmux. Developers love tmux. They'll defend tmux at dinner. The pressure came from something with no patience for workarounds, no muscle memory, no "I'll fix that alias later." Something that needs the primitive to exist right now or it fails the task.
Call it the compensation gap. alias ll='ls -la' (copy-pasted into ten million .zshrc files, promoted to "onboarding documentation"). PS1 one-liners for colored directories that break on every new machine. Symlinks held with ln -s and hope. Miserable little optimizations dressed up as institutional knowledge.
Agents can't do any of that. No .zshrc. No muscle memory. They need the primitive to exist. If you're building agent tooling without thinking terminal-native, you're already one cycle behind.
18 months of daily sessions with Claude Code, Codex, and others. Not theoretical friction. The kind where you lose 20 minutes staring at a tmux pane.
Programmable pane control. tmux splits fine. An agent can't control panes programmatically (it spawns blind, no instrument panel). Like handing someone a cockpit where everything works and nothing is readable.
End-of-task notification. You launch a long session, context-switch, and there's no native signal when it's done. For a human: annoying. For an agent orchestrating parallel sessions: compounding coordination failure.
Browser rendering inside the session. The MCP Chrome extension works. Technically. External, disconnects at the worst moments, and every round-trip pulls the agent partially outside its context. Latency accumulates inside the reasoning loop.
Visual verification without Playwright. 300MB+ dependency, detectable headless fingerprint, fragile initialization. That's infrastructure just to confirm a button renders.
These aren't niche problems. They're four walls of a box.
There's a compounding issue underneath: heavy MCP servers burn context window at a rate that would make you wince. Native CLI vs MCP overhead: 37k to 98k tokens per session (a significant fraction of working memory gone before the agent writes a line of code). The MCP Chrome extension isn't slow because it's poorly built. It's external to the session. That's architectural.
Short term, most of this stays power-user territory. Protocol fragmentation is real (Kitty Graphics Protocol isn't everywhere, tmux support is partial). But the long-term trajectory is being systematically underestimated. That's exactly what Amara's Law predicts every time a platform shift looks like a toy.
When Non-Developers Start Talking About Ghostty, the Shift Already Happened
3,547 likes on a pastel Ghostty theme. Little bow. Cute messages. "Cute Ghostty." 😊
That's not the DevOps community. Those are people who've never opened a .zshrc, who learned what Ghostty is because it showed up looking adorable in their feed. When terminal aesthetics go viral outside developer circles, the cultural shift has already happened. You're not watching the beginning. You're watching confirmation that the beginning already passed.
This isn't new behavior. lazygit has millions of users. k9s has millions. btop has millions. None of them have a GUI. They won by being deployable anywhere, zero dependencies, no app store taking 30%. cmux is the same pattern, one layer up. The terminal-native playbook doesn't announce itself. Just ships.
What dies: Electron dev tools carrying 150-200MB Chromium runtimes because historically there was no other way to render HTML in a dev environment. If the terminal handles it natively, that payload becomes a question that gets louder every release cycle.
The terminal isn't evolving for us. It's evolving for what we built.
Fifty Years of Almost Nothing
The terminal is older than the internet. Older than the PC. Teletype machines, 1960s. Text over wire to mainframes. VT100, 1978, standardized escape codes. ASCII: a protocol so simple it ran on everything (serial ports, modems, SSH over 56k from a hotel room in 1998, a Raspberry Pi with no GUI, a Docker container with no display server).
Pure text in, pure text out. Seven-bit ASCII fits in a byte, a byte fits anywhere, and "anywhere" turns out to be a very large surface area. Developers didn't stick with the terminal out of nostalgia. Nothing else ran everywhere without conditions.
And yet structurally, for fifty years, almost nothing changed.
edlin, 1987. Then vim. Then tmux. Then Oh My Zsh (someone decided terminal prompts needed a plugin ecosystem with 300 contributors). What changed structurally: a few escape codes, better font handling. That's roughly it.
DevOps culture ran on compensation. Config files passed like sacred texts. Your .zshrc was a personality test. And somewhere in your fingers right now, there's a reflex that hits Esc then :w! (in vim, in SSH sessions, occasionally in Slack by accident). You stopped trying to unlearn it.
Outside that circle? Invisible. A black box developers disappeared into before emerging with software. Karen never had a reason to think about it.
Stable doesn't mean finished. Sometimes it means nobody needed it to change badly enough.
Until something arrived with no muscle memory to fall back on.
What Comes Next (And What's Already Late)
Short term: protocol fragmentation keeps this niche. Kitty Graphics Protocol isn't in Windows Terminal. Most JS-heavy SPAs won't render correctly. Power-user toy, for now.
Watch Microsoft. When Windows Terminal ships native Kitty Graphics Protocol support, the adoption curve breaks. They have every reason (WSL2, Azure dev environments, enterprise). That's the signal. Early majority follows within 18 months.
Long term (the part everyone's underestimating): the $5/month VPS with no GPU becomes a full visual dev environment. Gitpod and Codespaces get attacked from below.
Also, the scraping industry is going to feel it from a direction nobody modeled. The arms race there runs on one question: do you execute JavaScript? Playwright spawns Chromium (300MB+), Cloudflare detects the headless fingerprint, countermeasures get patched, repeat. Apify, ScrapingBee, Browserless built their moat on "we manage Chromium for you."
A terminal binary with native WebKit has a fingerprint profile those systems have never seen. No navigator.webdriver. No classic headless vectors. 2MB binary. That moat doesn't collapse overnight, but it erodes from a direction nobody's watching (same dynamic as the ad blocker wars in the 2010s).
The wildcard: the first AI agent that produces better results inside a terminal-native environment than outside it. Not because it's programmed to. Because shorter feedback loops, fewer external dependencies, unified execution context. That's the moment the industry stops asking "why terminal" and starts asking "why anything else."
Terminals survived everything. Not because they were perfect. Because they were everywhere: dev local, remote server, Docker container, CI/CD. And now: AI agent.
Code agents don't compensate. They need it to work natively. That pressure (not ours) is forcing the terminal to evolve. Ghostty, cmux: not tools for us. Answers to what we built.
The terminal has mutated. The infrastructure guy at Anthropic and the guy who built Ghostty are in the same ecosystem. The person who never touched a .zshrc is running agents in a black window. And /voice just put a microphone inside the thing that used to be a blinking cursor in 1978.
This isn't a hype cycle. Hype cycles plateau. This one has structural gravity. Every agent that ships, every tool that goes terminal-native, adds mass. It doesn't slow down.
And when Karen from Accounting reposts a pastel terminal theme because it's cute, the shift has already happened. You're just catching up.
clear **
Sources & links
- Ghostty — ghostty.org
- cmux — github.com/manaflow-ai/cmux
/voicein Claude Code — anthropic.com- Jarred Sumner / termbrowser demo — original thread on X
- Aakash Gupta — MCP token overhead research — X
If this landed, follow Rentier Digital. I write about building real automation with AI agents (the parts that ship, and the parts that break in ways you learn from).
(*) The cover is AI-generated. It has never touched a .zshrc in its life, and honestly it shows.
(**) command that clears the screen in terminal. Starts a new adventure ;-)
The terminal just became the control center for AI agents—and it's changing how we build software. Get the inside look at this infrastructure shift.