Set up CLI-Anything with a tellnova background agent

CLI-Anything is one of those repositories that reframes a problem you thought was settled. Instead of teaching AI agents to drive software the way humans do — screenshots, cursors, clicking through menus — it wraps the software itself in a structured command-line interface an agent can call directly. The project's tagline is "Making ALL Software Agent-Native", and with roughly 50,000 GitHub stars it has clearly struck a nerve. This guide shows the setup we walked through on video: install tellnova, then ask a tellnova background agent to set up CLI-Anything for you. An agent installing its own tooling is the whole point.

What CLI-Anything actually is

CLI-Anything comes from HKUDS and ships under Apache 2.0. It does two related things:

CLI-Hub is a catalog of pre-built, agent-ready CLIs for existing software — GIMP, Blender, LibreOffice, OBS Studio, Audacity, Draw.io, Godot, ComfyUI, and 90+ community-contributed wrappers. One pip install, and an agent can render a Blender scene or batch-edit images in GIMP through structured commands with JSON output.
The generator is a seven-phase pipeline that turns any codebase into a production-grade CLI: analysis, command design, implementation, test planning, test writing, documentation, and publishing. It runs as a single slash command inside coding agents — Claude Code, Cursor, Codex, and pi, the agent runtime tellnova runs on.

The project backs this with 2,461 tests validated against real software backends — no mocks, no graceful degradation. That discipline is why the generated CLIs are usable rather than demos.

Why agent-native CLIs change computer use

Watch an agent drive a GUI through screenshots and the inefficiency is hard to unsee. Every step is a round trip: capture the screen, reason over pixels, guess a coordinate, click, capture again to see what happened. Each loop burns tokens, time, and reliability — one moved dialog and the run derails.

A structured CLI collapses that entire loop into one deterministic call. gimp-cli batch-resize ./assets --width 1200 replaces dozens of screenshot-reason-click cycles, returns machine-readable output, and behaves the same every run. Nearly all of the overhead of GUI-driving simply disappears, which is why agent-native interfaces feel less like an optimization and more like a different category of computer use.

Set up tellnova first

tellnova runs background coding agents in isolated git worktrees — you fire a task, an agent works on it without touching your checkout, and you review and ship the diff. Setup takes a few minutes:

Download the desktop app from tellnova.com/#download for macOS, Windows, or Linux.
Sign in with GitHub.
Connect a model provider in Settings — a ChatGPT subscription via Codex OAuth, an OpenRouter key, Cursor, Kimi, GLM, or MiniMax. Bring whatever access you already pay for.
Pick a repository. tellnova clones it once and gives every task attempt its own worktree and branch.

Ask the agent to set up CLI-Anything

Here is the part that makes this workflow fun: you never open a terminal yourself. Start a new tellnova task and give the agent the job in plain language:

Install the CLI-Anything hub, list the available CLIs,
and install the GIMP wrapper. Verify it responds and
write a short usage note in TOOLS.md.

Behind the scenes the agent runs the same commands you would:

pip install cli-anything-hub
cli-hub list
cli-hub install gimp

You watch the log stream live in the thread. Because the run happens in an isolated worktree, anything the agent writes — notes, config, scripts — lands as a reviewable diff, not as mystery state on your machine. If the agent needs to research the repo's docs first, the Agent Reach skill gives it web access from inside the task.

Make your own software agent-native

The generator is where this compounds. CLI-Anything ships integrations for pi, and tellnova's agents are pi sessions — so you can point a background task at your own project and ask it to run the pipeline:

Run /cli-anything against this repository and take it
through all seven phases, including tests and docs.

The agent analyzes the codebase, designs the command surface, implements the CLI, writes unit and end-to-end tests, and documents it — all inside its worktree. When it finishes, you get the diff in tellnova's review view, and shipping it is one click: tellnova opens the pull request for you. Your software is now operable by any agent, and the change history shows exactly how it happened.

Agents that install their own tools

This loop — an agent setting up the tooling that makes other software agent-operable — is a preview of how development environments start to assemble themselves. The pattern is the same one behind giving tellnova agents internet access: install a capability once, and every future task can use it. CLI-Anything just extends that from research skills to the entire software on your machine. And the loop keeps going: the same pattern can turn your own codebase into a remote MCP server with MCP Maker.

Grab tellnova from tellnova.com/#download, star CLI-Anything on GitHub, and let a background agent do the setup while you review the result. The source for tellnova itself is at github.com/MannJadwani/tellnova.app.