Every project. Every agent. One terminal.

One prompt. Agents do the work.

I started with one constraint: there is only one prompt. Not one per project, per window, or per agent. You type your intent there, and agents do all of the work. You stop spending cycles on switching windows and deciding where to type what.

› @api run the tests
┌ api ─ fix-auth ──────────────────────────────────────┐
│ $ npm test                                           │
│   ✓ 214 passing (3.2s)                               │
└──────────────────────────────────────────────────────┘
› @api @billing bump the shared client to v2 in both
┌ api ─ agent ● working ───────────────────────────────┐
│ Editing package.json  +1 −1                          │
│ Running npm test                                     │
└──────────────────────────────────────────────────────┘
┌ billing ─ agent ● working ───────────────────────────┐
│ Editing package.json  +1 −1                          │
└──────────────────────────────────────────────────────┘
? fix-auth    Allow `git commit`?          [y] yes  [n] no
✓ perf-audit  3 N+1 queries found. Diff ready.  [r] review
api billing › █

 4 workspaces │ 3 agents │ 1 needs you │ ⌃␣ commands      12:04

You typed “run the tests.” An agent ran npm test. That’s the whole division of labor.

A new way of working

You don’t go to the work. The work comes to you.

Developer tools are organized around places: a window per project, a tab per server, a terminal per agent. That breaks when you run agents. New Terminal is organized around intent. Say what you want and where it should go, and the request goes there, wherever it lives.

Aspect	The old way	The new way
Where you work	A window or folder per project	One prompt for everything
What you type	Commands	Intent
Setting up	A shell, dotfiles, `PATH`, and version managers on every machine	Nothing: projects declare it, agents run it
Who does the work	You, one command at a time	Agents, in parallel
How work starts	Navigate there, then act	Name it, and the request goes there
Knowing what needs you	Check every window	It comes to you, at the same prompt
Your role	Operator of each tool	Director of all the work

How it works

Built for people who direct agents more than they edit files.

@mention, don’t navigate

Mention a project, a workspace, or an agent by name and the request goes there. Mention several and it goes to all of them. The prompt always shows where your next request goes.

Any agent, no lock-in

Claude Code, Codex, Cursor, OpenCode, and whatever ships next run as normal processes in normal panes, against whichever model provider you choose. A built-in agent works the moment you open the app.

The attention queue

The real bottleneck in agentic work is you. Every permission request, question, and finished diff waits in one queue, and you answer at the prompt. Yes-or-no takes a single key. You never poll.

One workspace per task

Each task gets an isolated workspace with its own branch, so parallel agents never step on each other in files or ports. A workspace brings in the projects it needs: local, remote, or cloud.

Local or cloud, same experience

Agents run on your laptop, in a sandbox, on your own servers, or in the cloud. Every one is a pane, a status, a workspace, and a diff. Your keys go straight to the provider.

On your phone

The same prompt on iOS and Android. Approve a permission, answer a question, or review a diff from the lock screen. Because you only type intent, the phone loses nothing.

Principles

Opinionated, native, and open.

Fast and interactive

Everything responds instantly and works from the keyboard. A slowdown is a bug.

Omakase

The chef chooses. One carefully tuned experience instead of a thousand toggles, with one plain text file for what you legitimately need to change.

Native on every platform

macOS, Linux, and Windows are first-class. No web app in a window. On a Mac it feels like a Mac app.

Open source, honestly

Apache 2.0. The whole local experience, agents included, is free forever. The test for any paid feature: would a solo developer on a plane miss it? If yes, it’s free.

Sessions that survive

Close the window, quit the app, reboot. Your agents, their shells, and their scrollback come back exactly where they were.

No account required

No cloud dependency for core use. It never requires its own model, cloud, or agent.

Non-goals

What it isn’t.

Not a shell. You never type commands; agents do.
Not a window manager. No window per project, tab per server, or terminal per agent.
Not an editor or an IDE. No file tree, no editor. Your editor stays in its own app.
Not a chat app. One prompt for everything, not a chat window per agent.
Not infinitely configurable. Opinionated, and tuned to be right.
Not a walled garden. Bring your own agent, model, and cloud.

Why “Terminal”

The original terminal, rebuilt for agents.

A terminal was originally the human’s end of a line to a computer doing work somewhere else. New Terminal goes back to that idea. The machines doing the work are now agents, spread across your laptop, your servers, and the cloud. The prompt is your end of the line to all of them.