⇅ Cheap-first escalation
Every subtask starts on the cheapest capable model and climbs the cost ladder only on failure. Premium rates are for work that earns them.
The most results per dollar of compute. A smart orchestrator plans and verifies; cheap or local executors do the work — and you watch every token.
One static binary. Any Anthropic or OpenAI-compatible endpoint — cloud or fully local. Validated before every merge, metered to the cent.
Live anatomy of a task
You talk to one agent. It decomposes the task, fans subtasks out to cheap executors in parallel — each in an isolated git worktree — validates the diffs, and merges only what passes. Every agent gets a tab. Every token gets metered.
How it works
A premium model breaks your task into self-contained subtasks and routes each to the cheapest executor that can do it well — it sees cost tiers and your budget.
Subtasks run in parallel, each in its own pooled git worktree. Scouts investigate (changes discarded, report saved); ships deliver code. Stuck executors are detected and escalated up the cost ladder automatically.
Your project's declared checks run and a fresh-context reviewer judges the diff — with bounded fix rounds — before anything touches your checkout.
Passing work merges, opens a PR (/delivery pr), or waits for your diff
sign-off (/nomistakes on). Failures stay on branches — never lost.
Why cheep
Firstmate-style safety: every shared write and command asks first, and nothing merges until you approve the branch diff in a scrollable preview. Headless runs hold everything on branches. cheep becomes physically incapable of surprising you.
/nomistakes on
┌ approve: merge → cheep/local-qwen-1 ─┐
│ + func LoadTOML(p string) … │
│ - func LoadJSON(p string) … │
│ y: allow · n: deny · ↑/↓: scroll │
└──────────────────────────────────────┘
Every subtask starts on the cheapest capable model and climbs the cost ladder only on failure. Premium rates are for work that earns them.
Checks + a fresh-context AI review gate every worktree before it lands. Failed work survives on its branch.
Per-project dollar caps: warn at 80%, hard-stop at 100%. /tokens shows spend
and savings live.
/fork any earlier turn to race a second approach without re-paying for
context; /tree navigates every branch.
Research subtasks discard their changes and file a report; only ships touch code. Audits on local models cost nothing.
/delivery pr pushes validated branches and opens pull requests — your
checkout untouched, safe on shared repos.
No API key? A bundled bridge routes hard reasoning through your logged-in Claude Code
(any Pro or Max plan — no API key) — or run Claude Code as the driver and let it offload bulk work to cheep's
free local executors via cheep run.
Run pi coding agent extensions from npm inside cheep:
cheep pi add <pkg> and their tools join every agent through an embedded
Node↔MCP bridge (TypeScript included).
Append :low|:medium|:high to any model — extended thinking on Claude,
reasoning_effort elsewhere. Planner thinks hard, workers stay cheap.
Say "run the test suite every weekday at 9am" and cheep schedules a recurring
job (interval or cron). /scheduled manages them; cheep daemon
fires them on cadence — run it in tmux and work happens while you're away.
When an agent struggles for lack of a tool, cheep spots the gap and offers to install the
fitting capability from a curated MCP catalog (web fetch, search, GitHub) — so a weak
researcher picks up real tools instead of guessing. On by default; curated-only and one-tap,
never arbitrary code. /autoimprove.
cheep reads each model's context window (cloud from the pricing dataset, local by
probing the server) and compresses & continues at ~75% instead of dying with
context_exhausted. A live gauge shows the fill.
Subtasks sharing one local model serialize per endpoint (they'd only queue anyway); distinct backends still run in parallel. Add a second model and the speedup returns.
iterate_until re-runs a cheap executor against your check (tests, lint)
until it exits 0 — bounded by rounds and budget.
Interrupted delegations are surfaced at the next launch with the branch that holds the
partial work. /stow writes a handoff note before you step away.
Renders inline in your terminal's own scrollback — native scroll, select, and copy.
/cd moves the agents to another repo mid-session. go test ./...
covers every feature here.
Showcase
Three scouts investigate in parallel on free local models; changes auto-discarded,
reports land in ~/.cheep/reports/.
› audit this repo: dead code, missing error
handling, flaky tests — one prioritized list
# three kind:"scout" subtasks, one delegate call,
# a tab per scout — checkout untouched
Objective checks loop on a cheap executor; each failure feeds back in, bounded by your budget.
/budget 2
› fix ./internal/parser until
`go test ./internal/parser` passes
# iterate_until{subtask, check} on the
# cheapest executor — rounds are ~free
No-mistakes mode: validation still runs, but the merge waits for your y/n on the diff.
/nomistakes on
› migrate the config package to TOML
# … executors work, checks pass, then the
# approval overlay shows the branch diff
On shared repos, never touch the checkout — validated branches become PRs.
/delivery pr
› split User into Identity + Profile,
update all call sites
# result: "pull request opened" + URL each
Fork the conversation from any turn — shared context is kept, not re-paid.
/fork # pick the turn to redo
› use a worker pool instead
/tree # both attempts side by side
Reasoning effort is a per-role model suffix; Ollama tags are untouched.
{ "orchestrator": { "model":
"claude-sonnet-4-6:high" },
"executors": [ { "model":
"qwen/qwen3.6-35b-a3b" } ] }
pi.dev extensions from npm run inside cheep; their tools reach every agent. Review third-party code first.
cheep pi add pi-web-access
› research the top 3 Go HTML sanitizers,
recommend one
# executors now have pi__web_search & co.
A markdown file is a command — $1..$9 and $ARGUMENTS
substitute; it autocompletes like a built-in.
$ cat .cheep/prompts/review.md
Review the $1 package. Focus: $ARGUMENTS
/review internal/worktree locking
Ask in plain language; cheep turns it into a cron/interval job. /scheduled
to manage, cheep daemon to fire them.
› run the test suite and fix failures
every weekday at 9am
# scheduled 0 9 * * 1-5 · manage with /scheduled
cheep daemon # fires jobs on cadence
An agent floundering for lack of a tool? cheep suggests the right MCP from a curated catalog and installs it on your OK — on by default.
› research the latest Postgres 17 features
# qwen has no web tool → auto-improve spots it:
🔧 fetch would help here — /autoimprove install
# added; agents can now read the web
The bundled bridge shells out to your logged-in Claude Code — whatever it's signed into, any Pro or Max plan — so a local orchestrator can hand the hard reasoning to Claude on your subscription. (Experimental; subject to Anthropic's usage policy.)
"mcp": { "claude": {
"command": "cheep-claude-mcp",
"roles": ["orchestrator"] } }
# orchestrator gains claude__ask_claude —
# hard bits run on your plan, grunt work stays local
The cleaner direction: Claude Code (your Pro/Max plan) plans and reviews; it offloads the
bulk implementation to cheep's free local executors via cheep run.
# in Claude Code, on your Pro/Max plan:
› build the appointments module
# Claude delegates the grunt work →
$ cheep run "write the routes + tests
for appointments" --workdir . --json
Run it anywhere
cheep is a plain terminal app, so the most reliable portable setup needs zero new software: run it in tmux on your machine and attach from anywhere over Tailscale SSH — the same live session, running task, agent tabs, and pending approvals. A long delegation keeps working while your phone is in your pocket, and crash markers mean interrupted work is surfaced, never stranded.
tmux new -As cheep # attach or create
cheep
› refactor the storage layer;
run the full suite when done
ssh my-mac -t 'tmux attach -t cheep'
# flaky signal? mosh roams + survives sleep:
mosh my-mac -- tmux attach -t cheep
Pair with /nomistakes on so nothing merges without your sign-off
while you're away, and /stow before a break to write
a handoff note. Full setup — Tailscale, phone keyboards, cheat sheet — in the
portable guide.
Install
brew install TedHaley/homebrew-tap/cheep
go install github.com/TedHaley/cheep@latest
Then just run cheep — first launch discovers local model servers (Ollama, LM
Studio, vLLM, llama.cpp) and API keys on your machine and walks you through picking an
orchestrator and executors. Setting up a project? cheep init
scaffolds AGENTS.md with detected validation checks.
Reference
| CLI | |
|---|---|
cheep | interactive shell (setup on first run) |
cheep run "…" --json | one-shot task; JSONL events for CI |
cheep init | project launchpad: AGENTS.md + checks |
cheep validate --review | run checks + AI review of the diff |
cheep jobs … | manage recurring scheduled tasks |
cheep daemon | fire scheduled jobs on their cadence |
cheep pi add <pkg> | install a pi.dev extension |
cheep upgrade | update to the latest release (brew or self-replace) |
cheep check | ping every configured agent |
| In the shell | |
|---|---|
/nomistakes /approval | sign-off on merges · gate risky calls |
/autoimprove /scheduled | self-installing tools · recurring jobs |
/fork /tree /history | branch, navigate, resume sessions |
/delivery merge|pr | how validated work lands |
/budget /tokens /cd | cap spend · cost + savings · move workspace |
/prompts /stow | templates · handoff note to disk |
/config /setup | configurator · configure by chat |