Command line may be the most user-friendly interface for AI agents.

Article author and source: Minority Report

Between 2025 and 2026, top AI companies successively released a type of product: CLI-based agent tools.

Anthropic released Claude Code, an AI programming assistant that runs in the terminal. OpenAI released Codex CLI, and Google released Gemini CLI. In this wave, almost every noteworthy AI company has bet on the command line.

This is counterintuitive. Command lines are a product of the 1970s, GUIs brought computers to the masses, and now mobile internet has made touchscreens the default. Logically, technology should be becoming increasingly "visual" and "easy to use." Why is the oldest form of interaction making a comeback in the AI era?

The answer isn't sentimentality, it's engineering logic.

GUI is not AI-friendly

GUIs are designed for human visual navigation. Buttons, pop-ups, drag-and-drop, hover effects—these interaction paradigms are built on human visual intuition. Humans glance at the interface, scan the button locations, and intuitively determine the next action. This mechanism is extremely natural for humans, requiring almost no learning curve.

But LLMs don't work that way at all. LLMs take tokens as input and output tokens as output. Their "thinking" happens in the language space, not the pixel space.

Enabling AI to control the GUI means crossing a huge chasm:

The understanding cost is extremely high. AI needs to rely on computer vision or Accessibility Trees to "understand" the interface—which button is clickable, where which input box is located, and what the current pop-up means. This is not AI's strength; rather, it is an additional burden.

The state is implicit and unpredictable. The same button might be clickable today, but grayed out tomorrow due to some condition. This implicit state is "context" for humans, but uncertainty for AI—it cannot reliably reason "under what conditions this operation is available".

Operations cannot be combined. There is no way to pipe together two GUI operations. "Search Results → Filter → Export" is three clicks in the GUI, and cannot be passed, reused, or automated as a whole.

It's difficult to test and verify. How do you confirm that an AI has successfully performed a GUI operation? You need to take screenshots and analyze the interface state; the entire feedback loop is slow and fragile.

In contrast, every feature of CLI seems to be designed specifically for AI.

CLI's three major advantages for AI agents: composability

The core of the Unix philosophy is: "Each program does one thing, and does it well; programs can work together."

This design principle from decades ago has taken on new meaning in the AI era.

CLI tools use standard input and output chaining. `linkly search "React performance optimization" | head -5` passes the search results to the next command. `linkly search "architecture design" --json | jq '.results[].doc_id'` extracts all document IDs for later processing.

For AI agents, composability means that multiple commands can be chained into complex, multi-step workflows, with each step's output being structured text that can be consumed by the next step. There's no GUI-based "click → wait → screenshot → parse" loop; only clean input and output.

Predictability

The behavior of each command is entirely determined by its parameters. A linkly search for "database" with `--limit 10` will produce the same result today, and the same result tomorrow (assuming the database hasn't changed). There is no implicit state, and no confusion about why a function worked before but doesn't now.

This is extremely important for AI. When AI reasones about a tool, it needs to build a mental model: what are the tool's inputs, what are its outputs, and what are its side effects? The implicit state of a GUI makes this mental model uncertain. The explicit parameters of a CLI make this mental model reliable and accurate.

The command `linkly read 42 --offset 80 --limit 100` means that the meaning of this command is entirely determined by the parameters. The AI can infer its behavior precisely without needing to guess any implicit context.

Auditability

All CLI operations are recordable text sequences. What commands the AI executes and what output it receives are all human-readable text.

This transparency has two advantages.

For the AI itself: it can perform self-checks. "The previous linkly search for 'contract template' returned 0 results, indicating that the keyword was incorrect. Try using 'contract template' instead." This text-based self-correction is the foundation for the reliable operation of the AI Agent.

For humans: Post-implementation review is possible. You can view which commands the AI executed, what the input and output were at each step, and the entire inference chain is clear at a glance. GUI operations' "clicks" are difficult to trace, while CLI operation logs naturally serve as audit records.

Linkly AI CLI Design Practices

LinklyAI is our own in-house developed search engine and knowledge base creation software. From the very beginning, when designing LinklyAI's CLI tools, we considered the AI Agent as one of our primary users.

4 carefully designed core commands

The Linkly AI CLI has only four core commands:

These four commands perfectly conform to the Unix philosophy: each does only one thing and has a clear input-output contract. The AI Agent can combine them arbitrarily into complex retrieval processes.

A typical agent workflow is as follows:

The output at each step is structured text that can be directly consumed and reasoned by AI. There is no GUI operation and no burden of visual parsing.

Combined with pipes, etc.

Another advantage of CLI is that it can be freely combined with other commands in the system to bring new capabilities beyond the boundaries of a single tool.

Filtering and Extraction : --The JSON output can be directly used to extract fields using jQuery, and the results can then be passed to the next tool.

• # Search for documents, retrieve only the list of doc_ids, and then batch retrieve the outlines.
• Linkly search "database design" --json | jq -r '.results[].doc_id' | xargs -I{} linkly outline {}

Combining with grep for secondary filtering : First, use semantic search to narrow down the scope, then use precise keywords for filtering.

• Linkly search "architecture design" | grep -i "microservices|distributed"

Statistics and Analysis : Perform document statistics using tools such as wc, sort, and uniq.

• # How many PDFs are in the statistical knowledge base?
• linkly search "" --json | jq '.results[].type' | sort | uniq -c

Integration with scripts : Batch processing and automation of repetitive tasks within shell scripts:

GUI tools cannot participate in these combinations. CLI tools output a text stream, which can be consumed by any other tool, making the overall system far more powerful than the simple sum of the individual tools.

CLI is also the simplest MCP bridging method.

CLI and MCP are not mutually exclusive. A single `linkly mcp` command can turn the CLI into a stdio MCP server, usable by any AI client that supports MCP:

Json:

This is much simpler than configuring an HTTP MCP server directly—users don't need to know the port number, don't need to manually write the URL in the JSON, they just need to tell the AI client "run this command".

CLI has become the entry ticket to the MCP ecosystem, requiring almost zero configuration friction for users.

A broader trend

Claude Code's decision to prioritize releasing the CLI format over an IDE plugin is based on a clear engineering logic: IDE plugins are limited by the host environment, while CLI tools can run anywhere with a terminal, can be invoked by any agent, and can be combined with any other tool.

This reveals a more fundamental principle: the essence of an AI agent calling a tool is executing commands. Tool invocation (function call/tool use) is semantically CLI—given a name and parameters, it returns a result. CLI tools are naturally functions that the agent can call, requiring no translation layer.

The phrase "Terminal as the new IDE" was coined long before the rise of AI, but it has acquired a completely new meaning in the AI era. It's not just about "writing code in the terminal," but rather "Agents interacting with the world through terminals."

In the past, CLI was a tool exclusively for technicians. In the future, CLI may become the universal language of agents—humans will communicate with agents through natural language, and agents will interact with systems through CLI.

summary

The status of the GUI will not be greatly affected; it remains the best interface for humans to directly operate computers. However, when your AI tool needs to call another tool, the CLI is the most natural bridge, and more software will release more CLI tools to adapt to agent habits.

Want to try searching your documents in the terminal? Check out these two articles: Let AI search your documents without leaving the terminal and let 30+ AI tools read local files with a single command.