Terminals for the Agentic Era

Warp has evolved from a modern terminal into a full agentic development environment. It became open source in April 2026 and runs on macOS, Linux, and Windows.

The standout feature is the Automation Platform, Warp's cloud agent orchestration system (formerly branded "Oz"). It supports multi-harness orchestration, meaning it can launch, track, and control Claude Code, Codex, and Warp's own Agent sessions in parallel in the cloud. You get a unified control plane with automatic multi-agent orchestration, cross-harness Agent Memory (currently in research preview), session handoff from local to cloud to phone, and ways to start cloud agent runs automatically: on a schedule, through an API, or from integrations with Slack, Linear, and GitHub. That makes it suited to background work such as sorting new issues, reviewing pull requests, and recurring maintenance. During the current beta period, multi-harness orchestration is available to all users regardless of tier.

Warp also includes Warp Agent (its built-in coding AI with access to frontier and open-source models including Claude Fable 5, Claude Opus 5, GPT-5.6, Gemini 3.1 Pro, Grok 4.6, GLM 5.2, and Kimi K3, available in the app and in the Warp Agent CLI), Warp Drive for sharing workflows and environment variables, and support for bringing your own API keys on paid tiers. Warp can also run third-party CLI agents like Claude Code, Codex, and OpenCode directly inside the terminal, wrapping them with its agent toolbelt for rich input, code review, and notifications. Warp Factories goes a step further than a single cloud agent: it gives a team a group of cloud agents attached to its code repositories. It picks up work from Slack, GitHub, Linear, or Jira, takes it through triage, spec, implementation, and review, and hands the result back where the request started, usually as a pull request (a proposed code change ready for review), with humans approving the key decisions.

Pricing

• Free: $0/month, no included agent usage (pay for extra agent usage at pay-as-you-go rates or bring your own inference), Warp Agent CLI access, limited cloud agents, 3 indexed codebases (3,000 files each), 30 stored cloud conversations, up to 10 team members.
• Build: $20/month, or $18/month billed annually, with $20 of agent usage included each month at API rates, full access to frontier and open-source models, 20 concurrent cloud agents (2 vCPU/4 GiB RAM each), 40 indexed codebases with up to 100,000 files each, unlimited cloud conversation storage, up to 10 team members.
• Max: $200/month, or $180/month billed annually, with $200 of agent usage included each month (10 times Build), cloud agents with 4 vCPU/8 GiB RAM, up to 10 team members.
• Business: $50 per user/month, or $45 per user/month billed annually, for teams up to 25 seats, with $20 of agent usage included per seat each month at API rates, 80 concurrent cloud agents (8 vCPU/16 GiB RAM each), 80 indexed codebases, SAML-based SSO, admin-configurable data controls, team usage metrics, and bring your own API keys and custom inference endpoints.
• Enterprise: Custom pricing, unlimited seats, custom shared usage pools and terms, advanced spend controls, enterprise admin controls and data governance, an analytics and usage API, multi-admin support, self-hosted cloud agents, and the option to route inference through your own cloud (BYOLLM on AWS Bedrock and Google Vertex AI, with Azure AI Foundry coming soon).

Warp Factories has its own price list, and the agent work it does is billed separately on top, based on the AI, computing time, and agent runs used. Pay as you go is $0/month with usage at 20% above API rates and up to 10 team members. Build is $20/month with usage at API rates, Claude Code and Codex alongside Warp's own agent, and factory setup stored in your own GitHub. Business is $50 per user/month for up to 50 team members, adding SAML-based SSO, team usage reports, and bring your own API keys. Enterprise is custom priced, with self-hosted workers and data and your own AI provider. Every plan runs cloud agents on Linux, Mac, and Windows machines.

Included agent usage is a dollar allowance spent at API rates; on paid plans you can add more usage, turn on auto-reload, and set a team-wide spending cap. How much an action costs depends on the model used, the size of the task, how much context and codebase are involved, and whether the agent runs locally or in the cloud. Cloud and managed-agent runs can also include platform and compute costs.

Best for: Teams that want a managed, governed platform for running multiple agent harnesses in parallel without stitching together their own infrastructure. Warp is the only terminal that natively orchestrates Claude Code, Codex, and its own agent in parallel cloud environments with a unified dashboard.

cmux is a free, open source (GPL-3.0) native macOS terminal built by Manaflow AI. It uses libghostty (the rendering library from Ghostty) for GPU-accelerated terminal rendering, making it extremely fast while also being purpose-built for coding agent multitasking.

cmux is a shipping product at version 0.64.10 (released 23. 5. 2026), available as a direct DMG download from GitHub. It has 20,300 GitHub stars and 138 release tags, indicating active development and growing community adoption.

Key Features for Agent Workflows

• Notification rings: Panes light up when agents need attention, directly solving the "which of my five agent sessions is waiting for input?" problem.
• Vertical tabs: Display git branch, working directory, active ports, and notification text at a glance.
• In-app browser: Can be split alongside a terminal pane, useful for previewing what an agent is building.
• Socket API and CLI: Programmatic control for automating agent session creation and management.
• Horizontal and vertical split panes: Standard multi-pane support within each tab.

cmux is agent-agnostic and works with Claude Code, Codex, OpenCode, Gemini CLI, Kiro, Aider, and any other CLI tool.

An optional Founder's Edition is available for supporters, offering prioritized feature requests and early access to upcoming features (cmux AI, iOS app, Cloud VMs, Voice mode). The core product is and will remain free.

Limitations

macOS only for now. cmux is a terminal emulator, not a multiplexer, so there is no session detach/reattach. If you close the app, your agent sessions end. For persistent sessions, you would still need to run tmux or Zellij inside cmux. There is also no built-in cloud orchestration like Warp's Automation Platform.

Best for: macOS developers who want a terminal that was designed from the ground up for multi-agent workflows, with visual cues (notification rings) that tell you at a glance which agents need attention, all without paying for a subscription.

These terminals were not built specifically for AI agents, but they provide the raw performance, pane management, and scripting capabilities that form the foundation of any multi-agent setup. Most power users pair one of these with a multiplexer (tmux or Zellij) for session persistence.

Ghostty

Created by Mitchell Hashimoto (co-founder of HashiCorp) and open sourced in late 2024. Ghostty is a fast, cross-platform terminal emulator with GPU-accelerated rendering and platform-native UI. It supports split panes, tabs, configurable keybindings, and the Kitty graphics protocol for inline images. Importantly, Ghostty exposes libghostty as a reusable library, which is what cmux builds on. Available on macOS and Linux (no Windows). Free and open source.

For agent work: Excellent rendering speed makes it comfortable for watching multiple agent outputs. No session persistence, so pair with tmux or Zellij. A solid choice as the "raw terminal layer" under a multiplexer.

WezTerm

A powerful cross-platform terminal emulator and multiplexer written in Rust. WezTerm combines terminal emulation with built-in multiplexing, meaning it can replace both your terminal and tmux. Its Lua-based configuration is extremely programmable, supporting scripted creation of complex pane layouts. SSH integration with native remote multiplexing is built in. Available on macOS, Linux, Windows, and FreeBSD. Free and open source.

For agent work: The combination of terminal + built-in multiplexer + Lua scripting makes WezTerm uniquely suited for power users who want to script complex multi-agent layouts (for example, automatically creating 10 split panes each running Claude Code in different git worktrees) without depending on tmux. Cross-platform support including Windows is a key differentiator.

iTerm2

The long-standing macOS terminal replacement, now at version 3.6.10 (built April 2026). iTerm2 offers split panes, tabs, profiles, triggers, instant replay of terminal output, and a Python scripting API. It added modest AI features in the 3.5/3.6 series (an AI chat using OpenAI's API with bring-your-own-key). Available on macOS only. Free and open source.

For agent work: The standout feature is tmux integration mode, which renders tmux sessions as native iTerm2 panes and tabs. This gives you the persistence of tmux with the native feel of iTerm2, which is particularly useful for remote agent sessions over SSH. The Python scripting API enables sophisticated automation of pane creation.

Wave Terminal

An open source terminal (v0.14.5, April 2026) that blends terminal, editor, and AI into a single workspace using a block-based layout. Terminal sessions, file editors, web previews, and AI chat all live side by side as draggable blocks. Wave AI is built in and supports multiple LLM backends. SSH connections are first-class citizens. Available on macOS, Linux, and Windows. Free and open source.

For agent work: The block-based workspace concept is compelling for having an AI chat block next to multiple terminal blocks running agents. SSH is deeply integrated. However, Wave lacks session persistence and agent-specific features like notification indicators.

Terminal multiplexers solve a critical problem for agent workflows: session persistence. When you close your terminal or disconnect from SSH, your running agents die. A multiplexer keeps them alive in the background, letting you detach and reattach at will. This is essential for long-running agent tasks and remote development.

tmux

The battle-tested multiplexer that has been the backbone of remote terminal work for over a decade. tmux provides session detach/reattach, windows and panes within sessions, full scriptability via shell commands (tmux new-session, tmux split-window, tmux send-keys), and a plugin ecosystem via tpm (tmux plugin manager). It runs on macOS, Linux, BSDs, and WSL on Windows. Free and open source.

For agent work: tmux has become the de facto infrastructure for the entire multi-agent ecosystem. Tools like dmux (1,600+ GitHub stars) create tmux panes for AI agent sessions with automatic git worktree creation, supporting Claude Code, Codex, OpenCode, and more. Claude Squad (7,700+ stars) manages multiple agent sessions in tmux workspaces. ccmanager (1,100+ stars) supports 8+ different agent CLIs with session state detection. These orchestration tools all build on tmux as their session and pane backend. The main downside is that tmux's keybinding system and configuration syntax are arcane compared to modern alternatives.

Zellij

A modern terminal multiplexer written in Rust, positioned as a tmux alternative with better usability and a WebAssembly plugin system. Zellij offers split panes, tabs, floating panes, session management with detach/reattach, and discoverable keybindings (it shows available shortcuts contextually). Its layout system uses KDL files to define complex pane arrangements declaratively. Available on macOS and Linux (no Windows). Free and open source.

For agent work: The layout system is ideal for defining repeatable agent workspaces. You can write a layout file (for example, claude-parallel.kdl) that specifies six panes, each configured to run a Claude Code instance in a different git worktree. Session persistence means agents keep running even if you disconnect. Floating panes are useful for ephemeral monitoring dashboards. The WebAssembly plugin system has potential for agent-aware extensions, though the ecosystem is still maturing. More user-friendly than tmux, especially for developers who have not invested years in customizing a .tmux.conf.

A new category of tools has emerged in 2025 and 2026 specifically to solve the parallel agent management problem. These are not terminals or multiplexers themselves; they run on top of them. If you are running three or more agent sessions in parallel, these tools are likely more important than which terminal emulator you use.

• Vibe Kanban (26,600+ GitHub stars): The most popular option. Provides a full kanban board with inline diff review and support for 10+ agents including Claude Code, Codex, Gemini CLI, and GitHub Copilot. Installs via npx vibe-kanban. Apache 2.0 license.
• Superset (11,400+ GitHub stars): A desktop app (macOS) that orchestrates CLI-based coding agents across isolated git worktrees. Supports Claude Code, Codex, Cursor, and more. Unified dashboard showing status, progress, and file changes. Elastic License 2.0.
• Claude Squad (7,700+ GitHub stars): The most popular CLI/TUI option. Written in Go, installs via Homebrew. Manages multiple agent sessions in separate tmux workspaces with background task completion. AGPL-3.0 license.
• dmux (1,600+ GitHub stars): A Node.js CLI that creates a tmux pane per task with isolated git worktrees and branches. Supports smart merge, AI branch naming, and GitHub PR creation. MIT license.
• ccmanager (1,100+ GitHub stars): A terminal-based session manager supporting the widest range of agents (8+, including Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode, and Kimi CLI). Offers session state detection and context transfer between sessions. MIT license.
• Nimbalyst (646 GitHub stars): Differentiates with visual WYSIWYG editors for markdown, mockups, and diagrams alongside session management, plus a mobile app for monitoring sessions on the go. MIT license.

All of these tools use git worktree isolation as their core mechanism. Each agent gets its own copy of the repository in a separate worktree, preventing merge conflicts when multiple agents edit the same codebase simultaneously.

The "best" terminal depends on how many parallel agent sessions you run and whether you want a managed platform or a DIY approach.

For managed, governed multi-agent orchestration (teams and enterprises)

Warp + the Automation Platform is the only terminal that provides a unified control plane for running Claude Code, Codex, and other agents in parallel in the cloud with observability, session handoff, memory, and governance. The cost starts at $20/month for individuals and $50/month per seat for teams. This is the highest-friction but most complete solution.

For individual developers who want a free, DIY approach

tmux + an orchestration tool (dmux, Claude Squad, or ccmanager) is the most proven combination. tmux provides session persistence and pane management; the orchestration tool automates worktree creation and agent launching per pane. This is what most power users in the Claude Code community use today. Pair with Ghostty or Kitty as the underlying terminal emulator for fast rendering.

For developers who want agent-aware terminal UX without paying for Warp

cmux is the most interesting new entrant. Its notification rings (panes light up when agents need attention) and socket API for scripting directly address multi-agent pain points. However, it is macOS only and relatively new. Ghostty + tmux remains the safer choice for now.

For developers who prefer a modern multiplexer over tmux

Zellij offers an excellent layout system and session persistence with more approachable keybindings. Its KDL layout files let you define a repeatable multi-agent workspace declaratively. A strong choice for developers who find tmux's configuration syntax intimidating.

For cross-platform support including Windows

WezTerm is the best option. It combines terminal + multiplexer in one app, runs on Windows, macOS, Linux, and FreeBSD, and its Lua scripting enables sophisticated automation of multi-pane agent setups.

For a quick, visual overview

Vibe Kanban or Superset provide the most polished desktop experience for managing multiple agent sessions with visual dashboards, regardless of which underlying terminal you use.

One of the most important factors for agent work is whether your sessions survive disconnections. AI coding agents can run for minutes or even hours on complex tasks. Losing a session because your laptop went to sleep or your SSH connection dropped is painful.

Which tools provide session persistence?

• tmux and Zellij: Full detach/reattach. Sessions keep running in the background indefinitely. The gold standard for persistence.
• WezTerm: Built-in multiplexer with session persistence, including across SSH connections.
• Warp (Automation Platform): Cloud agents run independently of your local terminal. Sessions persist even if you close Warp entirely.
• iTerm2: No native persistence, but its tmux integration mode provides it through tmux.
• Ghostty, cmux, Wave, Kitty: No session persistence. Close the window, lose the session. Pair with tmux or Zellij.

Remote development patterns

Many developers run agents on a remote server (a VPS or cloud instance) so they can disconnect their laptop without interrupting work. The typical setup is:

1. SSH into the remote server.
2. Start a tmux or Zellij session.
3. Launch Claude Code or Codex inside the multiplexer panes.
4. Detach and go. The agents keep working.
5. Reattach later from any device to check progress.

iTerm2's tmux integration mode is particularly useful here because it renders the remote tmux session as native iTerm2 panes and tabs, giving you a polished local experience while the work runs remotely.

A side-by-side overview of every terminal and multiplexer covered in this guide.

Tool	Type	Platforms	Agent Features	Session Persistence	Price
Warp	Agentic terminal	macOS, Linux, Windows	Automation Platform orchestration, multi-harness, cloud agents	Yes (cloud)	Free tier; paid from $20/mo
cmux	Agentic terminal	macOS	Notification rings, socket API	No	Free, open source
Ghostty	Terminal emulator	macOS, Linux	None (fast rendering, libghostty library)	No	Free, open source
WezTerm	Terminal + multiplexer	macOS, Linux, Windows, FreeBSD	None (Lua scripting for automation)	Yes (built-in)	Free, open source
iTerm2	Terminal emulator	macOS	Modest AI chat, tmux integration mode	Via tmux integration	Free, open source
Wave	Terminal + workspace	macOS, Linux, Windows	Built-in AI chat, block layout	No	Free, open source
tmux	Multiplexer	macOS, Linux, BSDs, WSL	None (foundation for dmux, Claude Squad, etc.)	Yes	Free, open source
Zellij	Multiplexer	macOS, Linux	None (KDL layouts, WASM plugins)	Yes	Free, open source