Agents Love the Command Line

For most of computing history, software has had one audience to design for: humans. The interfaces, the buttons, the dashboards, and the chat windows have all been built around how we like to work.

The future is about humans and agents working together, and the software systems that will succeed in the modern era will need to deliver both a great UX (user experience) and a great AX (agentic experience).

That shift is happening in real time, and most of us are still catching up to what it means.

(Quick note: HubSpot just launched its Agent CLI in private beta today -- built from the agent's perspective from day one. If you want to skip ahead and apply, here's the link. Otherwise, read on for why this matters.)

So today, I want to break down:

• Why CLIs have always been a great fit for power users (and now for agents)

• UX vs. AX -- the two interfaces modern software ought to deliver

• What it means to design an interface for an agent

—@dharmesh

Meet The Command Line Interface (CLI)

A quick definition before we really get into it.

A CLI is a command-line interface, which is just a fancy way of saying you type commands into a terminal (that black-screen-with-text setup) instead of clicking around in a graphical user interface (a GUI).

Consumer software lives in the GUI world because it's friendlier and less intimidating. The CLI world is older and less forgiving, but it's often dramatically more efficient once you know what you're doing. Technical folks have been using CLIs for decades, and for a lot of tasks the command line is still the most efficient way to do things in a system.

To be clear, GUIs aren't going anywhere, and they're still how most people interact with most software. That's exactly how it should be.

Notice the emphasis on people there? Agents have very similar preferences to technical humans.

Tell an agent "open the dashboard, click into Reports, filter by these fields, then export the result" and you're asking it to navigate a maze designed for human eyes and mouse clicks. Tell it "run this command with these parameters" and you're speaking its native language: less ambiguity, fewer steps, less context burned.

Agents love CLIs. And that’s why…

A Tale of Two Experiences: UX and AX

For years now, software companies have competed on UX. Software designers are paid salaries to pour their time into dreaming up intuitive user interfaces. I don't see that changing anytime soon. How a user feels as they navigate your product is vitally important to its success.

BUT there's a second user now, and that user is an agent. The software that succeeds in the modern era will need to deliver both a great UX and a great AX.

An agent doesn't care about your color palette or your hover states. It cares about whether your data is accessible, your commands are predictable, and your outputs are structured in a way it can digest efficiently. It wants token efficiency, because every token it uses carries a real cost. And it wants clear errors when something breaks, so it can decide what to try next.

This is no longer a secret. Plenty of software companies are making strategy adjustments to prepare for the agentic era -- but many are trying to cut corners.

The easy path, for any software company building agent tooling, is to take the command line they already built for developers and call it agent-ready. You ship in a week instead of a quarter. The infrastructure already exists, the team knows how it works, nothing new has to be designed.

But that command line was written for humans! An agent reading those outputs has to work harder than it should -- parsing pretty tables, decoding errors written for human eyes. Every wasted step costs tokens and makes the agent more likely to give up or do the wrong thing.

A great AX isn't a tweaked version of a great UX. It's a parallel discipline that asks different questions.

What 'Agent-Native' Actually Looks Like

Designing an interface for an agent, instead of for a developer, is the part of this shift I want to spend time on, because I think it's the most important.

Agents reach into software primarily through three doors:

• API -- built for developers writing integrations. Agents use it one endpoint at a time, so multi-step work burns tokens.

• MCP -- a brand new protocol built for agents, letting them discover what software can do without hard-coded integrations. The catch: coverage is still thin.

• CLI -- built for technical folks and used for decades. Agents use it for precise commands and structured outputs. The catch: it's typically designed for humans unless conscious effort is made to redesign it.

Many software companies already have a CLI. But few have considered rebuilding it with agent experience in mind, and I believe that's a big mistake.

A developer wants a command they can remember and type quickly, the agent wants a command that finishes the whole job in one call. Developers want outputs that look good in a terminal, agents want outputs they can parse without guessing. Developers want errors that help them think, agents want errors they can act on programmatically.

When you build an agent-native interface, the agent stops wasting tokens orchestrating and starts shipping real work.

The Era of Working Together (with Agents)

The future is about humans and agents working together. Which means the software you build, buy, and run has to work efficiently for both audiences at once.

I'm watching software companies grapple with this in real time. Most are still treating agents as an afterthought, bolting on something after the human product is done. A few are starting from the agent's perspective from day one. Those are the ones I'd bet on.

That's exactly the bet we made with HubSpot's new Agent CLI. As I mentioned up top, it's live in private beta today, giving agentic systems like Claude Cowork and OpenAI's Codex a convenient, token-efficient way to access HubSpot.

After reading this newsletter, it should be no surprise to you that we took the intentional route -- completely reimagining the CLI from the agent's perspective.

If you're a HubSpot customer and want to see what that looks like from the inside, you can apply for the private beta here: https://dharme.sh/hsclisignup

It's still very early, and there's a lot we're going to learn from watching real teams use it. I’m very curious (and excited!) to see what people build with it.

As always, let me know what you think. Feedback is my favorite gift 🙂

—Dharmesh (@dharmesh)