Essay ·
Your next user is an agent
I lead a design organization, and the most heavily used interface I shipped this spring has no pixels. It is a command line: 80+ commands across 13 data domains, wrapping a pharmaceutical intelligence platform so that a question about drugs, trials, deals or regulation becomes one typed line. Humans use it. But its heaviest user, by orders of magnitude, is not a person. It is whatever AI agent is doing the analysis that day.
That sentence describes most software's near future. The agent-native movement has a slogan I think about a lot: today's software serves humans; tomorrow's users will be agents. Projects like CLI-Anything are systematically wrapping the world's software so agents can drive it, and the wrapper of choice keeps being the oldest interface we have. Not because of nostalgia. Because for this user, it is the best one.
Why agents love the command line
Consider what an agent actually needs from an interface. Text in, text out, because language models live in text. Composability, because real work is pipelines, and a CLI hands you pipes for free. Determinism, because the same command should mean the same thing on the thousandth run. Self-description, because an agent can read help text the way a person reads onboarding. Testability, because you can put a command in CI and know your interface still works. A graphical interface offers an agent none of this; it offers a screenshot and a prayer. A command line is not a downgrade from a GUI for this user. It is the native medium.
There is a quieter reason too: auditability. When an agent works through a CLI, its actions leave a legible trace, a script of exactly what it did that a human can read, replay, or veto. For anyone who cares about trusting agents with real work, the interface that makes every action a sentence is a governance feature, not a convenience.
This is interface design, whether we claim it or not
Here is what surprised me while building: every classic UX concern reappears, wearing different clothes. Naming commands is information architecture; get it wrong and your user cannot find the capability. Flags are affordances. Help text is onboarding. Error messages are the most-read microcopy in the product, and for an agent they are also the recovery path: a good error tells the agent what to try instead. A structured output mode is the accessibility layer for machine readers. Even progressive disclosure shows up: the design question of what one command should do versus what deserves a subcommand is the same judgment as what belongs on one screen.
And it is dual-audience design, which is the genuinely new craft problem: the same tool must read well to a human at a terminal and parse cleanly for a process. Every command in my workbench answers in prose or in JSON, and keeping those two honest with each other is as real a design constraint as responsive layout ever was.
Where this leaves MCP
I say this as someone who has built 50+ MCP servers: protocols like MCP and plain CLIs are not rivals, they are different grips on the same handle. MCP gives agents a live, standardized connection into a running service. A CLI gives them a composable, deterministic tool that works in any harness, pipes into anything, and tests like ordinary software. My own pattern has settled into both: MCP where the agent needs a conversation with a service, a CLI where the work is discrete commands a pipeline can hold. The strategic point is upstream of the choice: your product needs an agent-facing interface, and someone is going to design it.
The uncomfortable part
That someone, today, is almost never a designer. The agent-facing surface of most products is being shaped by whoever wrote the API client, with no research, no information architecture, no error-message craft. Meanwhile agents are becoming the intermediary through which software gets chosen, operated, and recommended. How well an agent can drive your product will shape what that agent tells its human about your product. That is an experience, it has users, and it is currently shipping undesigned.
Our discipline spent decades earning a seat wherever humans meet software. The next seat is where agents meet software, and it is empty. I would rather designers take it while it is still cheap.
The practice behind this: cortellis-cli · the movement: CLI-Anything · the reverse angle: The door where the designer gets in · more in the lab