Terminal Emulators for Running Multiple AI Agents

For decades a terminal emulator had one job: draw a single session (one human, one prompt) as fast and cleanly as possible. Every fast, modern terminal is a beautifully optimized answer to that problem.

Then AI coding agents changed the workload. You’re no longer running one session. You’re running three, or four, or a dozen. Each is an agent streaming output, most of them off-screen while you look at one. That’s a different problem than “draw one session fast,” and the terminal built for the old job doesn’t automatically win the new one.

The old assumption: one session, as fast as possible

Terminals like Ghostty, Alacritty, Kitty, and WezTerm are GPU-accelerated. They move text drawing onto the GPU so a single fast-scrolling session stays buttery smooth. It’s genuinely excellent engineering, and for one session (or one AI agent) they fly.

But GPU acceleration optimizes how fast one window draws. It doesn’t change how many sessions are doing work at once. A terminal still parses each session’s output, lays it out, and keeps its buffer, per session, whether or not you’re looking at it. The agent in a background tab is still streaming; the terminal is still processing it.

Run one agent and none of this matters. Run four and the costs stack:

• Each agent streams output continuously, so several sessions are doing layout work at the same time.
• Background sessions you can’t even see are still churning through their agent’s output.
• The faster the agents produce output, the more paint and layout work piles up across all of them at once.

The result is a terminal that felt instant with one agent and warms up your fan with four. It’s not a bug; it’s the single-session design meeting a workload it was never shaped for.

Built for a soloist, or built for an orchestra

A fast single-session terminal is built for a soloist: render one performer perfectly. Running a team of agents is an orchestra: many players at once, most of them not the one you’re watching this second, and the whole thing has to stay light.

That’s the problem crystl’s terminal engine, cavrn, is built around. crystl’s workload is unusual for a terminal: a single window holds many shards (sessions) streaming agent output at the same time. So cavrn is designed for exactly that shape instead of the single-session one:

• Off-screen shards cost almost nothing. A hidden shard flooding output does nearly zero render work. Going from two agents to a dozen stays light on your Mac, because you only ever pay full freight for the one you’re looking at.
• The visible shard repaints only what changed. Not the whole screen every frame, just the rows that moved.
• Agent output is structured data, not just pixels. cavrn captures every turn, tool call, result, and table as typed records, so agents can read each other’s sessions and history search works across all of them. (More in Terminal GPU Rendering and the engine internals.)

Drawn on the GPU with Metal, cavrn is fast for a single session too, but the win that matters for AI work is what it skips when most of your agents are off-screen.

What else changes when you run many agents

Rendering is the part that quietly taxes your CPU, but a multi-agent workflow needs more than a light renderer:

• Organization beyond tabs. Gems and shards group sessions by project, so a dozen agents don’t become a wall of anonymous tabs. More on the habits that keep this straight in managing multiple AI coding sessions.
• Approvals you won’t miss. Agents pause to ask permission. In a plain terminal that prompt is just text in one of many streams, easy to miss. crystl floats them as glass panels, color-coded by project. See how to monitor multiple agents for what a fleet actually needs to surface.
• Parallel work without collisions. Two agents on the same repo need isolation. crystl backs isolated shards with real git worktrees so they never step on each other. The git worktree guide covers the mechanic itself.
• Sessions that survive. Agent context is valuable; closing a window shouldn’t lose it. crystl keeps structured history you can search across every shard.
• Agents that keep going. Queue a task backlog, auto-approve the safe operations, and push the decisions that need you to your phone. See how to run AI coding agents for longer.

For a tour of everything crystl keeps on disk while it does this, see the crystl filesystem.

The terminals, and where each fits

None of this makes the fast single-session terminals bad. They’re the right tool for the job they’re built for.

• Ghostty. GPU-accelerated, fast, thoughtfully designed. Superb for a single session and general terminal work.
• Alacritty. Minimal and GPU-accelerated, no tabs or splits by design; pair it with tmux or a window manager. Great for raw single-session speed.
• Kitty. GPU-accelerated with more built in (tabs, splits, image rendering) and Python extensibility.
• WezTerm. GPU-accelerated, cross-platform, Lua-scriptable, with built-in multiplexing.
• iTerm2. The mature macOS workhorse: splits, profiles, triggers, tmux integration.
• Terminal.app / Windows Terminal. The capable defaults for macOS and Windows.
• crystl. A macOS terminal built for the multi-agent workflow: cavrn keeps a fleet of agents light, approvals surface as panels, isolated shards run in parallel, and any CLI agent (Claude Code, Codex, and more) is a first-class citizen. Purpose-built rather than general-purpose.

Bottom line

If you run one agent at a time, any fast terminal is great. Pick the one you enjoy. The moment you’re running three or four agents at once, the question flips from “how fast does one window draw?” to “how lightly does it hold the sessions I’m not watching?” That’s the workload crystl and cavrn were built for.

The honest setup for most people: a fast general-purpose terminal for everyday shell work, and crystl for the AI coding sessions where you’re conducting a whole orchestra of agents at once. If that’s where you are, agent orchestration is the next thing to read.