AI tools in the terminal: what exists and when to use what

Not everything called an agent is one. Three classes of tools and the jobs they were built for.

2 min · · Updated · cli · development · choosing a model

Console AI tools often get lumped together and called agents. In practice there are three distinct classes with different jobs, and confusing them leads to reaching for the wrong one.

One-liners in a pipe

The simplest class: the program reads stdin, sends it to a model, prints the answer to stdout.

bash
cat error.log | llm "explain what broke here"
git diff | llm "write a commit message"

The tool has no state, knows nothing about your project and touches no files. That is exactly why it is predictable and fits pipelines and scripts.

Where it fits: one-off questions about text already in your terminal. Reading a log, explaining an unfamiliar command, drafting a commit message.

Where it does not: anything needing several steps or knowledge of project structure.

API wrappers

The middle class: the program holds a conversation, remembers history within a session, and can take files as arguments. But decisions about what to read and what to change stay with you.

Where it fits: work on specific files when you already know which ones. Translation, refactoring a single module, generating tests for a function.

Where it does not: tasks like "work out why the build fails", where half the job is knowing where to look.

Agents

Claude Code, Codex and similar. The difference is fundamental: an agent decides for itself which files to open, which commands to run and in what order. It runs a loop toward a result rather than answering one question.

Hence the cost: each step resends the accumulated context, so input token spend grows non-linearly. A dense session runs to hundreds of thousands of input tokens, and their price is what determines the bill.

Where it fits: multi-file edits, reading an unfamiliar repository, tasks with no obvious plan.

Where it does not: anything you could do yourself in a minute. On such a task an agent costs more of your time reading the diff than it saved.

How to choose

TaskClass
Explain command outputone-liner
Commit message from a diffone-liner
Rewrite a single modulewrapper
Write tests for a functionwrapper
Find why the build failsagent
Project-wide refactoragent

A rule that saves both money and time: take the simplest class that solves the task. An agent on a one-liner's job is not a mistake, but it is extra money and an extra diff to review.

Common to all three

All three classes work over an API and connect the same way: a base URL and a key. OpenAI-compatible tools take the address with a /v1 suffix, Anthropic-compatible ones without it.

That means one key serves the whole set, and the model can be switched per tool: something cheap for routine, something strong for investigation. The current model list is at GET https://api.zukko.pro/v1/models; prices and context are at GET /v1/models/info or on the Models page in the dashboard at zukko.pro.

zukko

Pay 25×
less

for Claude Code & ChatGPT

One fetch_* key and base URL api.zukko.pro — for Cursor, Claude Code, Codex, and any SDK.

Get API keyDocumentation

api.zukko.pro · fetch_*

AI in the terminal: agents, wrappers, one-liners · Zukko