Zed's Terminal Threads Let Developers Run Claude 15-30x Cheaper
Zed v1.3 brings Terminal Threads to the Agent Panel, letting you run Claude Code, Amp, or any CLI agent as a managed sidebar thread alongside native AI workflows.
- Terminal Threads: Run
claude,amp,codex, or any CLI agent as a managed thread in Zed's Agent Panel sidebar. - Cost driver: Anthropic's new billing makes ACP-based Claude Code 15-30x pricier for heavy users; Terminal Threads restore subscription-based usage.
- Subagent model setting: New
agent.subagent_modellets you route cheap subtasks to a faster/cheaper model, saving cost on long agentic sessions. - Git improvements: New History tab shows all branch commits; custom Git commands now available from the Git Graph context menu.
- Inline rendering: Agent threads can now display images and Mermaid diagrams directly in the panel.
- Available now: All features ship in Zed v1.3, free to download on macOS, Windows, and Linux.
Zed just shipped v1.3, and the headline feature is one that a lot of developers have been quietly hacking together on their own: the ability to run terminal-based AI agents directly inside the editor's Agent Panel. The feature is called Terminal Threads, and it turns any CLI process into a first-class thread in Zed's sidebar, right next to your built-in agent conversations.
If you've been running claude, amp, or codex in a split terminal pane while Zed's built-in agent worked in another panel, this release is for you. The terminal pane was not designed for managing parallel agent sessions, and it showed. Terminal Threads fix that by bringing those sessions into the same sidebar where Zed already tracks agent work.
How Terminal Threads Actually Work
Open the "New Thread" menu from the + icon in the Agent Panel toolbar and choose Terminal. A new terminal opens in the panel body and appears as its own entry in the Threads Sidebar, just like any other thread.

Each terminal is scoped to your project and worktree. The terminal title in the sidebar updates automatically to reflect whatever is running, so you can tell your threads apart at a glance. You get the same keyboard navigation as regular agent threads, and notifications when a process needs your attention.
A few things worth knowing:
- You can open as many terminal threads as you like, and mix them freely with Zed Agent threads, ACP threads, or both.
- Terminal Threads can also be useful for non-agent work, like keeping long compiles and eval runs visible alongside the rest of your workspace.
- For Amp users: setting the environment variable
AMP_FORCE_BEL=1lets Zed notify you when an Amp thread finishes. - For Claude Code users: Terminal Threads are now the only way to keep using Claude Code in Zed with your existing Claude subscription, following Anthropic's changes to how Agent SDK usage is billed on subscription plans.
The Cost Angle You Shouldn't Ignore
There's a practical financial reason this feature matters right now. Anthropic recently announced that Agent SDK usage on subscription plans is moving to a separate, limited credit system. That makes running Claude Code through ACP significantly more expensive, 15-30x more for heavy usage. Terminal Threads sidestep this entirely by running Claude Code as a plain CLI process under your existing subscription, with no ACP overhead.
The Other Big Features in v1.3
The release also includes a Git panel branch history view, support for running custom Git commands from the Git Graph context menu, inline image and Mermaid diagram rendering in the agent, a new subagent_model setting, and optional text icons for completion items.
The subagent_model setting deserves a closer look. In Zed's agentic workflow, a "subagent" is a secondary model instance the main agent can spawn to handle subtasks, like running a search or reading a file, without using the main model's expensive context window. The new setting lets teams route specific tasks to cheaper or faster models instead of burning through expensive context windows on routine queries. The configuration looks like this:
"agent": {
"subagent_model": {
"model": "gpt-5-mini",
"provider": "openai"
}
}The recommended pattern is to use a frontier model (like Claude Opus or GPT-5) for the main agent, and a faster, cheaper model for subagent calls. This can meaningfully cut costs on long agentic sessions without sacrificing quality on the tasks that matter.
Other notable additions in this release:
- Inline images and Mermaid diagrams now render directly inside agent threads, so the agent can show you a chart or diagram without you leaving the panel.
- Git History tab in the Git panel shows all commits on the current branch in a single scrollable list.
- Custom Git commands can now be run from the context menu on any commit in the Git graph, using new task variables.
- Completion menu kind badges: enable with
"completion_menu_item_kind": "symbol"to show a single-letter type indicator next to each autocomplete entry.
Terminal Threads vs. ACP: Two Different Bets
It's worth understanding the distinction between Terminal Threads and Zed's existing Agent Client Protocol (ACP). ACP is an open standard, similar in spirit to the Language Server Protocol, that lets agents integrate deeply with the editor. Just as the Language Server Protocol unbundled language intelligence from monolithic IDEs, the goal with ACP is to enable switching between multiple agents without switching your editor. JetBrains is collaborating with Zed on ACP, and the protocol has been gaining traction across the ecosystem.
But ACP requires agents to implement the protocol. Zed built Terminal Threads because Zed should work with the tools developers already use, not only the ones that speak ACP. The two approaches are complementary: ACP gives you tighter editor integration (real-time edit visualization, multi-buffer review), while Terminal Threads give you immediate compatibility with any CLI tool, no protocol implementation required.
Terminal Threads are available now in the latest Zed release. Download or update to get started.