cheep — a multi-agent coding shell you can watch

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.

Install cheep See it work ↓

Live anatomy of a task

One prompt in. A supervised fleet out.

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.

cheep — ~/projects/api
orchestrator
tokens 0 spent $0.00 saved vs premium $0.00 idle

How it works

Plan · delegate · validate · land

Plan

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.

Delegate

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.

Validate

Your project's declared checks run and a fresh-context reviewer judges the diff — with bounded fix rounds — before anything touches your checkout.

Land

Passing work merges, opens a PR (/delivery pr), or waits for your diff sign-off (/nomistakes on). Failures stay on branches — never lost.

1 planner
spend premium tokens only where judgment matters
$0 executors
local models do the bulk of the work for free
100% metered
live tokens + dollars per agent, and what you saved

Why cheep

Frugal by architecture,
safe by default.

No-mistakes mode NEW

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     │
└──────────────────────────────────────┘

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.

Validated merges

Checks + a fresh-context AI review gate every worktree before it lands. Failed work survives on its branch.

$ Budgets that bind

Per-project dollar caps: warn at 80%, hard-stop at 100%. /tokens shows spend and savings live.

Session tree NEW

/fork any earlier turn to race a second approach without re-paying for context; /tree navigates every branch.

🔍 Scouts & ships NEW

Research subtasks discard their changes and file a report; only ships touch code. Audits on local models cost nothing.

PRs, not merges NEW

/delivery pr pushes validated branches and opens pull requests — your checkout untouched, safe on shared repos.

Use your Claude subscription NEW

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.

π Pi extensions NEW

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).

:high Reasoning per role NEW

Append :low|:medium|:high to any model — extended thinking on Claude, reasoning_effort elsewhere. Planner thinks hard, workers stay cheap.

🕒 Scheduled jobs NEW

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.

🔧 Auto-improve NEW

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.

Fits your model NEW

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.

No thrashing NEW

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.

Loop until green

iterate_until re-runs a cheap executor against your check (tests, lint) until it exits 0 — bounded by rounds and budget.

Crash-proof NEW

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.

Native terminal, anywhere NEW

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

Impressive things, and exactly
how to run them.

01Scout swarm audit

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

02Fix-until-green, nearly free

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

03Nothing lands without you

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

04Ship pull requests

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

05Race two approaches

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

06Think hard, work cheap

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" } ] }

07Borrow pi's ecosystem

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.

08Your own slash commands

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

09Schedule recurring work

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

10Agents that fix their own gaps

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

11Use your Claude subscription — no API key

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

12Or let Claude Code drive cheep

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

Walk away mid-task.
Pick it up on your phone.

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.

On your machine (once)

tmux new -As cheep   # attach or create
cheep
› refactor the storage layer;
  run the full suite when done

From your phone, anywhere

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

Thirty seconds to a fleet.

Homebrew · macOS & Linux

brew install TedHaley/homebrew-tap/cheep

Go

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

Commands

CLI
cheepinteractive shell (setup on first run)
cheep run "…" --jsonone-shot task; JSONL events for CI
cheep initproject launchpad: AGENTS.md + checks
cheep validate --reviewrun checks + AI review of the diff
cheep jobs …manage recurring scheduled tasks
cheep daemonfire scheduled jobs on their cadence
cheep pi add <pkg>install a pi.dev extension
cheep upgradeupdate to the latest release (brew or self-replace)
cheep checkping every configured agent
In the shell
/nomistakes /approvalsign-off on merges · gate risky calls
/autoimprove /scheduledself-installing tools · recurring jobs
/fork /tree /historybranch, navigate, resume sessions
/delivery merge|prhow validated work lands
/budget /tokens /cdcap spend · cost + savings · move workspace
/prompts /stowtemplates · handoff note to disk
/config /setupconfigurator · configure by chat