Original video in Chinese.
Key Takeaway
- Command-line Agents are an important direction for AI development, combining a vast tool ecosystem, classic Unix composability, and modern AI orchestration capabilities.
- The Unix philosophy (everything is a file, do one thing and do it well, programs work together) aligns closely with the AI model’s ReAct framework (the cycle of thinking and acting).
- The core capabilities of a general-purpose Agent include perception, thinking, action, and iterative validation.
- Large language models are responsible for “thinking,” while command-line Agents are responsible for “acting.”
- MCP (Model Control Protocol) is the key to implementing “perception” and “iterative validation.”
- The “skeleton” of a general-purpose Agent is an AI brain that is good at thinking, grafted onto a command-line body with massive tools, and supplemented by MCP’s sharp perception.
Let me ask you a question:
Why are major companies like Anthropic and Google all building command-line-based programming tools?
Imagine this: we spent decades evolving from those code-filled “little black windows” to today’s beautiful, intuitive graphical interfaces. We’ve gotten used to using a mouse, but then something weird happened:
Anthropic released Claude Code, Google released Gemini CLI, and overnight, these top-tier AI tools collectively “regressed” back to that “Stone Age.”
Is this really history running backward, or have these top experts seen a future that ordinary people like us completely missed?
In this episode, I’ll break it down for you step by step. Once you understand it, you’ll be able to see the direction in which general-purpose Agents are developing.
I suggest everyone save this first, because the content may be a bit deep and needs to be chewed over a few times.
First, we need to understand what Claude Code and Gemini CLI, built by these major companies, actually are.
One word: command-line Agent.
Why use a command-line Agent? What value does it have?
I think:
Command-line Agent = vast tool ecosystem + classic Unix composability philosophy + modern AI orchestration capabilities
Don’t worry, I’ll explain every concept in this formula in detail. Let’s start with the most basic one, which is:
What is the command line?
Simply put, in those ancient times, users gave instructions to computers by entering a line of commands, rather than interacting with computers through a graphical interface with a mouse like we do now.
So where did users enter commands? On something called a terminal. Whether you use Windows or macOS, you can find a terminal. It’s essentially an interface where the user can type input and also see the computer’s feedback.
Next, after a command is entered, the computer needs to “translate” it. Why translate? Because they don’t speak the same language.
What we enter through the command line is made up of text strings, meant for humans to read, but machines can’t understand it at all. So the concept of the Shell, or shell, came into being, specifically to handle translation.
When the Shell finishes translating, it sends the command to the kernel, or Kernel.
So the whole chain from Command Line to Terminal, to Shell, and finally to Kernel is a very classic processing flow.
The most advanced thing about this setup is the separation of the shell and the kernel. Why separate them?
Take an analogy: there’s a top-tier restaurant.
The kernel is the back kitchen. It can make any dish, but it doesn’t talk directly to customers.
The shell is the gold-medal waiter. He understands the kitchen’s “jargon” and the customer’s “human language.” When the customer orders, he translates and places the order with the kitchen.
And the terminal is the dining table where the customer sits; it’s the place where the customer and the waiter interact.
So this genius design of “separating the shell and the kernel” is like saying: the waiter cannot go into the kitchen to cook, and the chefs in the kitchen cannot come out to take orders.
Everyone does their own job, and only then can the restaurant run efficiently. First, it’s safe: if the waiter falls over (the shell crashes), it won’t affect the kitchen’s ability to serve dishes (the kernel keeps running). Second, it’s flexible: the waiter can design new menus at any time based on the customer’s taste (developers can create new commands at any time), without having to rebuild the entire kitchen (modify the operating system).
This command-line tool ecosystem, starting from the Unix systems of the past, has developed and carried on generation after generation, and has become a very valuable resource pool.
That’s what “vast tool ecosystem” means in the formula above. Command-line Agents like Claude Code directly use all kinds of command-line tools to issue commands, and the efficiency is extremely high.
So what does the later part, “classic Unix composability philosophy,” mean?
Unix is an incredibly powerful operating system. Its “descendants” are everywhere, including Linux, macOS, and the BSD family. I especially like its three design philosophies:
First, everything is a file (Everything is a file). In Unix, hardware devices, processes, and network connections can all be abstracted as files. Then you can use the same simple operations, such as open, read, and write, to interact with them in a unified way.
Second, do one thing and do it well (Do One Thing and Do It Well). Programs should stay simple and focus on one core function. So a command is a program; one command focuses on doing one thing well.
Third, and most importantly — write programs to work together. This philosophy requires that the output of each program should be able to become the input of another program. This gave rise to one of the greatest inventions in Unix history: the pipe, that magical vertical bar |. It can connect the output of one command directly to the input of the next command, like a water pipe.
So when a command-line Agent is running, it’s very much like building with Lego. The command-line tools passed down from Unix are like a huge pile of Lego pieces. Then the command-line Agent uses that vertical pipe bar to string the relevant commands together according to different needs.
And this Lego-building method happens to fit the way models operate especially well.
Today’s models use the ReAct framework, which is a continuous cycle of thinking and acting.
When a request comes in, the model first thinks (Reason). It breaks the task down and figures out exactly which tools are needed, meaning which commands to use.
Then the model uses pipes to combine command after command and starts acting (Act).
Finally, once execution is complete, the system returns a result to the model, such as outputting a file. That way the model can observe (Observe) and see whether the task has been completed.
This is the last part of the formula: the “modern AI orchestration capability.”
So as you can see, the emergence of command-line Agents is built on decades of computer development. The tool ecosystem and composability philosophy inherited from Unix happen to be especially suited to today’s AI era. That’s why command-line Agents were born.
I have to say, I’m truly, truly impressed that Anthropic thought of reusing these relics from ancient times.
At this point, you may ask: is a command-line Agent a general-purpose Agent?
Not exactly. Don’t rush. First think about it: what capabilities does a general-purpose Agent need?
I think there are four: perception, thinking, action, and iterative validation.
Thinking is already there — that is, the model itself, the brain used for thinking.
Action is also there now — that’s the command-line Agents we just talked about.
As for perception and iterative validation, they rely on MCP. Through MCP, the Agent can fully understand the user’s intent and the current state of the system. Once everything is done, the Agent uses MCP again to confirm whether the task has been completed.
So the skeleton of a general-purpose Agent is an AI brain that is good at thinking, grafted onto a command-line body that has massive tools and understands the art of composition, and then paired with a set of sharp senses called MCP.
Once you understand this skeleton, you gain a “God’s-eye view” that lets you understand AI products and the evolution direction of general-purpose Agents. Whether it’s AI assistants, AI programming tools, or automation workflow software, their core cannot escape this “skeleton.”
This “skeleton theory” is my takeaway from a month of heavy use of Claude Code. In China, I dare say there are very few people who can explain this to you so thoroughly from this angle.
OK, that’s all for this episode. If you want to understand AI, want to become a super individual, and want to find like-minded people, come join our newtype community. See you next episode!