The terminal is the most underrated AI surface (and it's where rysh starts)

Everyone is building chat UIs for AI. Meanwhile the surface where agents are actually strongest has been sitting in your dock for 40 years.

The entire industry is racing to build chat UIs for AI. Bubbles, avatars, typing indicators — the works.

Meanwhile, the surface where agents are actually strongest has been sitting in your dock for forty years, and almost nobody is treating it as the main event.

I build rysh, an agentic terminal multiplexer, so obviously I would say this. But let me make the argument properly, because it's not nostalgia — it's a claim about where agents structurally fit.

Agents are made of text. So is the terminal.

Strip an AI agent to its skeleton and you get a loop: read text, decide, call a tool, read text output, repeat. Every tool call is a command. Every observation is a stream of characters.

Now ask: what environment was purpose-built for exactly that shape?

Not the browser — we spend billions teaching agents to click pixels on interfaces designed for human eyes. Not the IDE — a brilliant surface, but scoped to one activity. The terminal is the one place where the agent's native representation and the environment's native representation are the same thing. Commands in, text out. No translation layer, no screenshot parsing, no DOM archaeology.

Forty years of Unix tooling means the terminal already has an ecosystem of sharp, composable, scriptable tools — which, from an agent's point of view, is a pre-installed standard library for acting on the world. git, grep, curl, make, kubectl: your agent doesn't need an integration marketplace. It needs a shell.

The terminal is also where trust is cheap

Here's the underrated part: governance.

In a chat UI, an agent's actions are reports: "I've updated the file!" You're trusting a summary. In a terminal, actions are observable events: the actual command, the actual diff, the actual exit code, scrolling past in real time. Verification isn't a feature someone built — it's the medium.

rysh leans all the way into this. Every tool call an agent makes renders in the pane as it happens. File edits show a coloured diff before anything touches disk. Mutating shell commands stop and wait for your explicit approval; read-only ones flow without friction. The approval prompt is a keystroke, in the same window, in the flow of work — which is the only place approval prompts actually get read.

$ go test ./pkg/...     # you, in shell mode
[Esc Esc]
> fix the flaky test in pane_test.go   # same pane, now talking to the agent
  ● edit pane_test.go   [diff shown]   approve? y/n

Double-tap Escape and a rysh pane flips between shell and AI. Same working directory, same context, same scrollback. The agent isn't in another app describing your world — it's in your world.

"But normal people don't use terminals"

Correct — and this is where I'll be honest about the limits of the argument.

The terminal is the best surface for the people who build and operate software. It is a terrible surface for your customers and most of your colleagues. Any AI strategy that ends at the terminal is a developer toy.

That's why rysh treats the terminal as the starting surface, not the whole product. The same engine that powers a pane also powers headless autonomous agents, browser automation, and humanoids on external channels — email, website chat, Slack (with WhatsApp and phone on the roadmap). One agent definition in a markdown file; the terminal is where you build it, watch it, and govern it; the other surfaces are where it meets everyone else.

Think of it the way you think of servers: your customers never see your terminal there either, but nobody argues that's where control should live.

What "terminal-first" buys you in practice

Concretely, starting agent-side work in the terminal gets you:

• Zero-integration tooling. 46+ built-in agent tools in rysh, and every CLI you already have is effectively a tool too, gated by a safe-by-default allowlist.
• Real observability. Not a log exported later — the work itself, streaming past, in separable output streams per pane (shell, AI, chat, system).
• Headless operations. A terminal-native agent is scriptable by construction: rysh send mysession "run the deploy checklist" --mode prompt drives a live session from any shell, no UI attached.
• Sharing that means something. A pane can be shared live to a teammate (##share pane view) — they see the agent's actual terminal, not a slide about it.
• Persistence. Detach, close your laptop, reattach — the session and its agents keep their state. It's infrastructure, not an app.

And because it's a real terminal — PTY-backed, with a proper terminal emulator underneath — vim, htop, and less all just work. That matters more than it sounds: an agent surface you abandon every time you need to actually edit something is a demo, not a workplace.

The bet

Everyone else is betting the agent era looks like a chat window with better answers. The rysh bet is that it looks like an operations surface: agents doing visible work next to yours, in the environment where work already happens, governed at the point of action — and then deployed outward to every other surface from there.

One binary to see it for yourself:

brew install rysh-ai/rysh/rysh
rysh

We're recruiting design partners. If your team lives in the terminal and you want agents in the workflow with real governance, come shape the roadmap: rysh.ai/design-partner

Related: Every pane is a conversation · Meet rysh.ai