CLI-Anything: Turn Any App Into a CLI for Claude Code and Codex

CLI-Anything auto-generates command-line interfaces for GIMP, Blender, LibreOffice and more, giving AI coding agents real tool access.

What is CLI-Anything? #

CLI-Anything is an open-source project from HKUDS, the data intelligence lab at the University of Hong Kong that also built LightRAG. It takes a piece of desktop software, GIMP, Blender, LibreOffice, and generates a full command-line interface for it that a coding agent can operate. You point it at an app’s source code, a coding agent reads that code, and it builds a CLI complete with tests, documentation, and a skill file the agent can use to understand what the tool does. The repository has passed 54,000 stars and ships under the Apache 2.0 license.

TL;DR #

• CLI-Anything generates command-line interfaces for GUI software by having a coding agent read the app’s source code and map its features to commands.
• The project ships two things you can use separately: CLI Hub , a package manager for CLIs other people already built, and theCLI generator , a plugin that builds new ones from scratch.
• Every generated CLI supports a --json flag for clean, structured output, plus aREPL mode with undo and redo so an agent always knows the current state.
• Generated CLIs call the real software instead of reimplementing it. The LibreOffice CLI produces actual PDFs through headless LibreOffice, and the Blender CLI renders with real Blender.
• The generator runs a seven-phase pipeline , analyze, design, implement, plan tests, write tests, document, and publish, and the project reports more than2,400 passing tests across roughly 30 generated harnesses.
• The documentation recommends using a frontier-class model (the project mentions Claude Opus, Sonnet, and GPT class models) for reliable generation, since smaller local models tend to produce incomplete or incorrect CLIs.
• Works across several agent harnesses, including Claude Code, Codex, Cursor, Open Code, and GitHub Copilot CLI , via a skill or plugin install.

Seven tools to build an app. Or just Remy. #

Editor, preview, AI agents, deploy — all in one tab. Nothing to install.

Why does a CLI matter for AI agents? #

Most software is built for people: buttons, menus, windows, mouse clicks. AI agents are good at reading and writing text, not clicking pixels. That mismatch is the whole reason this project exists.

There are currently three common ways to let an agent drive a desktop application, and each has a real weakness. GUI automation, where the agent takes screenshots and clicks coordinates, is slow, expensive in tokens, and breaks the moment a UI element moves. Native APIs are better when they exist, but most consumer and creative apps don’t expose one, or the API only covers a fraction of what the app can actually do. The third option, rebuilding a lightweight clone of the app in Python, almost always ends up missing most of the original software’s features.

A command-line interface sidesteps all three problems. Agents already understand terminals. A CLI takes text in and returns text out. Every command carries a help page an agent can query to discover what’s possible, and in CLI-Anything’s case, every command also supports a --json flag that returns clean, structured output instead of free text the agent has to parse and guess at.

How does CLI Hub work? #

CLI Hub is the “use what’s already built” half of the project. It acts as a package manager for CLIs that other people have already generated and published.

To install it, run pip install cli-anything-hub (Python 3.10 or newer is required). After installation, cli-hub-list shows every CLI currently in the registry, which according to the demo already includes tools for Blender, Inkscape, Audacity, OBS Studio, LibreOffice, Kdenlive, Shotcut, draw.io, Zoom, Ollama, ComfyUI, FreeCAD, QGIS, Obsidian, and Zotero, among others. You can narrow results with cli-hub-search followed by a keyword, install a specific one with cli-hub-install-<name>, inspect it with cli-hub-info-<name>, and start it with cli-hub-launch-<name>.

One important catch: these CLIs call the real application underneath. Installing the GIMP CLI means you still need GIMP installed on your machine. The same applies to Blender, LibreOffice, and everything else in the registry. CLI-Anything isn’t reimplementing these apps, it’s giving an agent a text-based steering wheel for software that’s already there.

To hand this capability to an agent directly, the project provides a meta-skill, a skill that teaches the agent how to search and install tools from the hub on its own. It installs via npx skills add hkuds/cli-anything --skill cli-hub-meta-skill -g -y, where -g makes it a global install and -y skips confirmation prompts. This works with Claude Code, Codex, and several other agents that support the skills format. Once installed, a prompt as simple as “find appropriate CLI software in CLI Hub and complete the task” lets the agent search the registry, install the right tool, read its skill file, and start issuing commands without being told which tool to use.

How does the CLI generator build a new CLI? #

Remy doesn't build the plumbing. It inherits it. #

Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.

Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.

When the hub doesn’t have what you need, or you’re working with internal or proprietary software, the CLI generator builds one from scratch. It’s distributed as a plugin for Claude Code (and supports Cursor, Codex, Open Code, and other harnesses). Installation is two commands: /plugin marketplace add HKUDS/cli-anything followed by /plugin install cli-anything. Windows users need Git for Windows or WSL, since the plugin runs shell commands through Bash.

Generation itself runs through /cli-anything pointed at a local path or a GitHub URL, then proceeds through seven phases:

1. Analyze : the agent reads the source code and maps GUI actions to the underlying code that implements them.
2. Design : it plans command groups, a state model, and output formats.
3. Implement : it writes the actual CLI using Python’s Click library, including a REPL mode, JSON output, and undo/redo.
4. Plan tests : it writes atest.md file outlining unit and end-to-end test coverage.
5. Write tests : it implements the tests from that plan.
6. Document : it runs the tests, records results intest.md , and generates askill.md file other agents use to discover and understand the CLI.
7. Publish : it generates asetup.py and installs the CLI onto your system path.

Every generated CLI follows the naming pattern cli-anything-<softwarename>. Commands support JSON output for programmatic use, and running a CLI with no arguments drops into an interactive REPL that tracks state (for example, showing the current scene name in a Blender session and flagging unsaved changes).

Does the generated CLI actually use the real software? #

Yes, and this is one of the project’s stricter design rules. The generator follows a playbook file called harness.md that lays out non-negotiable constraints, the most important being that a generated CLI must call the real application rather than substitute a lighter library. The example given is that a generated tool must not swap in a Python imaging library in place of GIMP itself.

That rule extends to testing. An exit code of zero isn’t accepted as proof that an export worked. Tests instead check the real output artifacts, verifying file magic bytes, file structure, pixel content, audio levels, and duration, depending on what the software produces. If the real software isn’t installed on the test machine, tests fail rather than silently skip, which avoids the common trap of a CLI looking “green” while actually being broken.

Is CLI-Anything worth using? #

For anyone running agents against creative or office software, it’s a low-cost experiment with a potentially large payoff. Installing the CLI Hub meta-skill costs nothing and immediately gives an agent access to a wide registry of pre-built tools. Building a brand-new CLI with the generator is a heavier undertaking: the documentation recommends a frontier-class model for reliable results, since smaller or local models tend to produce CLIs with gaps or incorrect commands. Generation on a large codebase can also consume a meaningful number of tokens.

#

Plans first. Then code.

Remy writes the spec, manages the build, and ships the app.

There are real limitations worth weighing. The generator works best with access to source code; pointing it at a compiled binary with no source produces lower quality and narrower coverage. A single generation pass rarely covers an entire application’s feature set, so the project includes a refine command meant to be run multiple times, each pass comparing what the real software can do against what the CLI currently supports and filling gaps without deleting prior work. There’s also a validate command that checks a CLI against the harness rules, and a test command that reruns the test suite and updates the results file.

And because the CLI itself is agent-generated code, it deserves the same scrutiny any AI-written code would get. Reviewing the tests and checking what commands actually do before pointing it at important files or production data is a reasonable precaution, not an afterthought.

Frequently Asked Questions #

What is CLI-Anything used for?

It generates command-line interfaces for desktop GUI applications so that AI coding agents like Claude Code or Codex can operate the software through text commands instead of screenshots and mouse clicks.

Do I still need the original software installed?

Yes. Generated CLIs call the real application rather than replacing it. The LibreOffice CLI needs LibreOffice installed, the Blender CLI needs Blender installed, and so on.

Which AI coding agents support CLI-Anything?

The project works with Claude Code, Codex, Cursor, Open Code, GitHub Copilot CLI, and other agent harnesses that support plugins or skills.

How good does the AI model need to be to generate a usable CLI?

The project’s documentation recommends a frontier-class model, citing examples like Claude Opus, Sonnet, and GPT-5 class models, for reliable output. Smaller or local models are more likely to produce incomplete or incorrect CLIs.

Can I use CLI-Anything without building anything myself?

Yes. CLI Hub lets you install and use CLIs other people have already generated for popular software like Blender, GIMP, Inkscape, and LibreOffice, without running the generator at all.