We spend millions building beautiful visual dashboards for AI agents. But agents don't want a UI - they live in the CLI.
If you look at the current wave of AI tools, you'll see a massive amount of energy spent on building beautiful, visual interfaces. We are building sleek chat windows, draggable dashboards, and complex web applications.
We do this because we are humans. We need screens, buttons, and pixels to understand and control systems.
But AI agents aren't human. And they don't want a UI.
Lately, I've completely changed how I build systems for my clients and how I manage my own daily work. I stopped trying to force my agents to navigate human-centric interfaces, and I stopped setting up heavy, complex middle layers like Model Context Protocol (MCP) servers just to translate data back to visual dashboards.
Instead, I gave my agents direct, secure access to what they understand best: the command-line interface.
They live in the terminal. And when you let them stay there, the results are immediate.
The Weight of the Visual Bridge
When we force an agent to interact with a visual application, we pay a heavy tax.
To connect an agent to a user interface, we have to build translation layers. We set up MCP servers, configure webhooks, or write complex selectors to scrape screens. Every one of these layers is a new point of failure. It is more code to maintain, more latency, and above all, a massive waste of expensive tokens.
To an agent, a visual button is noise. It has to read the HTML, parse the state of the page, choose the correct element, and simulate a click.
This is slow, and it is completely unnecessary.
An agent is a language system. It doesn't need to see a button to click it; it just needs the command to execute. When you give an agent direct access to the CLI, you strip away all the dead weight. Instead of burning 50,000 tokens rendering a dashboard, the agent runs a single command, reads the raw data in milliseconds, and moves to the next task.
Running Native in the CLI
I've been pair-programming and running operations with tools like Claude Code and Antigravity. They are designed from the ground up to understand the terminal.
We don't do "vibe coding." Everything runs under strict, safe boundaries with structured workflows and local skills. But the efficiency is on another level.
Instead of waiting for a visual pipeline to compile or trying to map an API to a frontend page, my agent simply runs local commands. If it needs to edit a file, it uses a precise replacement tool. If it needs to build a carousel, it runs a Python script directly in the terminal. If it needs to publish, it calls the CLI of our publishing service.
The agent is swimming in its native environment. It's fast, lightweight, and incredibly precise.
Build for Machines, Not Just Humans
This shift is where the future of operations is going. We are moving away from traditional operating systems built with beautiful desktops for humans, and moving toward agentic operating systems built for digital workers.
When you build internal systems for your business, ask yourself: Who is this system really for?
If it's for a human worker, build a clean, simple UI.
But if you are building workflows to be executed by AI agents, stop building screens. Give them a CLI. Focus on building clean, structured commands, secure local scripts, and lightweight APIs.
Tokens are the new fuel. Stop wasting them on rendering buttons for systems that only read language.