Feishu Open-Sourced a CLI — Why Is Everyone Building Command-Line Tools for the AI Agent Era?飞书 CLI 开源了，为什么 AI Agent 时代，大家都在做命令行工具？

Feishu (Lark) just open-sourced a command-line tool called lark-cli that lets AI agents directly operate Feishu: send messages, check calendars, write documents, create multi-dimensional tables, send emails, manage tasks. You tell the AI one sentence, and it goes and operates Feishu to get the task done.

There are many similar CLIs. Three weeks ago Google also open-sourced gws, letting AI agents operate Google Workspace. It's 2026, and every product that wants to plug into AI agents is building a CLI.

First, what is a CLI

CLI (Command Line Interface) is when you open a black-background, white-text terminal window on your computer, type a line of command, press enter, and the computer does the work for you.

For example, if you want to check today's schedule, instead of opening the Feishu app and finding the calendar, you type one line:

And the schedule is listed out.

No buttons, no icons, no fancy interface. The CLI predates the graphical interface by more than twenty years, and it gradually fell out of use in the Windows era. But in the AI agent era, it's become popular again.

Why is everyone building CLIs in the AI agent era

For an AI agent to get work done, it needs the ability to operate tools. If you ask an AI to help book a meeting room, it needs access to the calendar system. If you ask it to organize customer data, it needs to be able to read and write spreadsheets. If you ask it to deploy code, it needs to be able to run deployment commands.

There has to be an interface for the AI to call. APIs can do this too, but a CLI has an advantage that an API doesn't: a CLI is self-describing. When an AI encounters an unfamiliar CLI, typing --help tells it what capabilities exist, how to use them, and how to fill in the parameters. Not so with an API — the AI first has to get the documentation, figure out the endpoints, and understand the authentication method before it can act. A CLI comes with its own manual built in; the AI can pick it up and use it right away.

Also, a CLI is naturally text-based in its interaction — input is text, output is text. Text is exactly what AI is best at handling. Conversely, having an AI operate a GUI is a roundabout process: it has to take screenshots, use a vision model to identify where the buttons are, and then simulate mouse clicks — turning something a single command could accomplish into four steps, each of which can go wrong. For AI, the CLI is a naturally suited operating interface.

What about MCP and skills

There are currently three mainstream ways to let an AI agent operate external services: MCP, CLI, and skills. The three aren't substitutes for each other — each handles a different job.

The CLI is the tool that actually does the work. Once it's installed, you can run commands in the terminal — checking calendars, sending messages, creating tables — all executed by the CLI.

MCP also lets AI operate external services, but in a different way. MCP registers a list of tools with the AI ahead of time, so the AI can call them anytime, but the list itself sits permanently in the context window (think of it as the AI's "working memory," which has limited space). Even if the AI doesn't need a particular tool at the moment, its description still takes up space. With a CLI, the AI goes to the terminal and types a command only when it needs to, then leaves — it doesn't occupy context.

Another difference is composability. A CLI can combine pipes and parameters into operations that were never pre-defined, for example:

One line of command can find out how many meetings you have with Zhang San next week. Every capability in MCP needs to be registered in advance; to achieve the same effect, you'd have to define a separate new tool.

That said, MCP has its own use cases. In environments that don't support the command line (such as Cursor or the Claude desktop app), MCP is the only option. The two each have their strengths: use CLI where terminal access is available, for lighter and more flexible operation; rely on MCP where terminal access isn't available.

Skills are the manual written for the agent to read. They don't do the work themselves, but they tell the agent what commands this CLI has, what parameters to use in which scenarios, and how to handle errors. An agent can still use a CLI without a skill file, by figuring things out through --help on its own. But with a skill file, the agent knows how to operate right from the start, and its success rate is much higher.

Simply put: the CLI is the hand, MCP is another kind of hand, and skills are muscle memory. Feishu's newly open-sourced project provides both the CLI and the skill file together.

How to write a good CLI for AI

You can't just write any old command-line tool and expect AI to use it smoothly. If you want to build an AI-facing CLI for your own product, Feishu's design has a few points worth referencing.

First, the help text is your most important piece of documentation. When an AI encounters an unfamiliar CLI, the first thing it does is run --help. Your help text is three things in one: the tool manual, the parameter specification, and the usage guide. Don't just write something like Usage: myctl deploy [flags] and call it done — spell out clearly what each parameter does, when to use it, and what its default value is. The Feishu CLI also has a schema command that can quickly look up the parameters, request body, response structure, and supported identity and permission scopes for any API method. Once the AI sees this information, it can decide on its own how to make the call.

Second, support dry-run — this is a safety net designed for AI. AI makes its own decisions, and sometimes it misunderstands your intent, or matches data it shouldn't touch. Dry-run functions as a "preview" mechanism.

For example, say you ask AI to help delete last month's expired records in a Feishu multi-dimensional table. If it executes directly, a mistaken deletion is gone for good. Add --dry-run, and the AI will run through it first and return something like: "The following 47 records are about to be deleted: 23 expired tasks from 2025-05, 24 archived projects. No actual changes have been made." You review it, and if it looks fine, you tell it to drop --dry-run and actually execute. Google's gws does the same thing — its skill file even hardcodes a rule: for all write and delete operations, dry-run must be done first.

Third, error messages should guide the next action. When a person sees "Permission denied," they go check the docs themselves. When an AI sees "Permission denied," it gets stuck. Feishu CLI's approach is: tell the AI which permission it's missing, and give it the command to request that permission at the same time. For example, lark-cli auth login --scope "calendar:calendar:readonly". Once the AI sees this, it can fix the problem itself and keep working. For a CLI designed for AI, every error message should contain three elements: which parameter is the problem, exactly what went wrong, and what command to run next to fix it.

Fourth, return structured data and control the output volume. The Feishu CLI supports multiple output formats such as json, csv, and table. For humans, table is easier on the eyes; for AI agents, json is more reliable. A good CLI isn't just one that runs successfully — it should also be easy for other tools to consume. At the same time, output volume needs to be controlled. AI's context window is limited; if a single command returns ten thousand lines of logs, the context blows up. The Feishu CLI provides pagination parameters (--page-limit) and filtering parameters, so the AI can get just the portion of data it needs.

Whether you're the one designing the CLI or the one using it, remember this: before letting the agent take action, have it do a dry run first.

Once installed, you talk, and the agent acts

Once installed, in practice it works like this: you say one sentence, and the agent goes and operates Feishu to get things done.

After a meeting ends, you tell the AI, "Pull out all the action items mentioned in that meeting just now — send documents for the ones that need documents, create tasks for the ones that need tasks." The AI reads the meeting notes, breaks down the action items, and executes them one by one: using lark-cli doc create to create documents in Feishu, using lark-cli task create to create tasks and assign them to the right people, and using lark-cli im send to notify the group of the results. You said just one sentence for the whole process, and the agent ran a string of commands in the terminal. And because there's dry-run, you can have it preview which tasks it's about to create and who they'll go to, and confirm before it actually executes.

If you need to schedule a meeting across five people in different time zones, you tell the AI, "Help me check when everyone is free next week." The AI checks everyone's calendars and time zones, recommends a few time slots, you pick one, and the meeting is set.

You can even have the AI write a first draft directly in a Feishu document for you; you leave comments in the document with your suggestions, and the AI reads the comments and revises on its own. The whole collaborative process never requires leaving Feishu.

Installation is simple too: npm install -g @larksuite/cli installs the CLI, and npx skills add https://github.com/larksuite/cli -y -g installs the skill file. You don't even need to remember these two steps yourself — just send the project address https://github.com/larksuite/cli to the agent and let it install itself and learn how to use it on its own.

The return of the CLI

Over the past forty years, the direction computer interfaces have evolved has consistently gone from CLI to GUI, from text to icons, from keyboard to touchscreen — becoming more and more friendly to humans.

In the AI agent era, the direction has reversed — the user of software has become the AI agent. The CLI, an interface designed for the world of text, happens to be the tool AI finds most natural to use.

Since agents have become software's new source of user growth, it's no surprise that Feishu is providing a CLI. Rather than wait for the community to write an MCP adapter layer, it makes more sense to build an AI-native CLI directly — fully open source, requiring no registration or approval, so that any AI agent can plug in.

This also brings up an unavoidable question: how should an agent's permissions be granted? Without permissions, it can't do anything; with too much permission, there's a risk that the agent misunderstands the intent and does something irreversible.

This also brings up an unavoidable question: how should an agent's permissions be granted? Without permissions, it can't do anything; with too much permission, there's a risk that the agent misunderstands the intent and does something irreversible. After all, we're not yet at the point where an agent can approve things on your behalf or send an all-staff email for you. Dry-run can cover part of the risk, but to truly get agents running at scale within an enterprise, the permission system, audit trails, and the boundaries of human-agent collaboration are all still being figured out.

But looking at it another way, back when we moved company money from the safe to online banking, and moved contracts from paper to electronic signatures, those were also things we figured out step by step. CLI and dry-run may just be the first step in this process.

And Feishu doing this actually has an advantage that others can't easily replicate: it's already mature enough in the enterprise collaboration space — messaging, documents, calendars, approvals, multi-dimensional tables, tasks — these capabilities are all already there. Now, opening up all these capabilities through an AI-native CLI will likely make it the most open and AI-agent-friendly enterprise-level access point domestically. The value of this isn't just one more tool — it's more like genuinely building enterprise-grade infrastructure for the agent era, opening up permissions, auditing, and organizational capabilities to the whole ecosystem. That will be a crucial step for the industry's adoption of AI agents.