You bring the vision. Your agents bring the hands. Vibe Terminal holds the baton.
You describe what you want. One sharp model plans it. A pool of cheaper agents build it. Every result gets proven before it's trusted. It all streams past you, live, while you sip your coffee. ☕
That's the vibe.
Terminal coding agents in 2026 are powerful — Claude Code, Codex, aider, gemini-cli, opencode, goose. But used solo they're lonely virtuosos: one brain, one context window, no one checking their work, and you either babysit a scrolling session or fly blind.
Vibe Terminal is the conductor. One reasoning model holds the score and directs. A pool of CLI agents — on whatever models you like — play the parts. Gates prove every note before it lands. And the whole performance scrolls past you live.
A conductor and an ensemble. You hear the whole thing happen.
╭───────────────────────╮
│ ORCHESTRATOR │ ← the brain: plan · route · verify
│ "hold the score" │
╰───────────┬───────────╯
scoped, grounded tasks │
╭───────────────┬─────────┴───────┬───────────────╮
▼ ▼ ▼ ▼
╭─────────╮ ╭─────────╮ ╭─────────╮ ╭─────────╮
│ WORKER │ │ WORKER │ │ WORKER │ │ WORKER │ ← the hands
│ opus │ │ sonnet │ │ haiku │ │ deepseek│
╰────┬────╯ ╰────┬────╯ ╰────┬────╯ ╰────┬────╯
╰───────────────┴────── events ───┴───────────────╯
▼
╭───────────────╮
│ EVENT BUS │
╰───┬───────┬───╯
tail -f ◀──╯ ╰──▶ TUI · web · jsonl
│
╭───────────┴───────────╮
│ GATES · LEDGER · COST │ ← the proof
╰───────────────────────╯
Most "cost savings" tools nag you with a meter that pauses your run. Vibe Terminal does it the way a good engineering lead does — by putting the right model on the right job.
You own a role table. Each role is pinned to exactly what you choose:
[orchestrator] # the reasoner — your sharpest, most expensive brain
adapter = "claude-code"
model = "claude-opus-4-8"
[[worker]] # the dev — solid mid-tier for real building
name = "dev"
model = "claude-sonnet-4-6"
playbook = "playbooks/senior-dev.md"
[[worker]] # the grunt — pennies for the trivial stuff
name = "quick"
model = "claude-haiku-4-5"
playbook = "playbooks/quick-fix.md"
[routing] # hybrid: a task's own pin wins, else auto-by-complexity
auto = { trivial = "quick", standard = "dev", complex = "dev" }
[[routing.escalate]] # only pay premium when a cheap attempt fails its gate
when = "fast_gate_red"
from = "quick"
to = "dev"The expensive brain never touches cheap work. The cheap model tries first; the gate — not the model — guarantees quality, so a cheap attempt is safe to make. If it fails, then you escalate. Most tasks never do.
→ Strong-model quality, at mostly cheap-model cost. By design, not by nagging.
Every task's role, model, and dollar lands in the ledger, so you see exactly where your credits went.
| 🎚️ Cost routing, first-class | A role table you control. Pin a task, or let the conductor auto-route by complexity. Optional escalation ladder. |
| 🔌 CLI-agnostic | Native adapters for NDJSON CLIs (~60 LOC each), plus a zero-code generic-exec that wraps literally any command with a TOML block. |
| 🧠 Model-agnostic | Opus, Sonnet, Haiku, mimo, GPT, Gemini, DeepSeek, local — mix freely. Each worker gets only its own credentials; the conductor's keys never leak in. |
| 👁️ Visibility-agnostic | One normalized event bus. tail -f, TUI, web, raw JSON — subscribe to as many as you want, all from the same run. |
| ✅ Proof over trust | Fast gates per task, full suite per phase. Green → commit. Red → roll back to baseline. Nothing is "done" until a gate says so. |
| 🧵 Fresh context, always | One task = one fresh session. No bloat, no silent compaction, no lost work. State lives in git + markdown you can read — never in a window you can't. |
| 📒 A ledger that can't lie | Append-only, written after the rollback decision — so it can never claim work that got reverted. |
| 🪶 Scars, not theory | Every design rule (L1–L14) was paid for in a real overnight build. The discipline is the product. |
# install (uses uv; fetches its own Python 3.12)
git clone https://github.com/zkasuran/vibe-terminal && cd vibe-terminal
make install
# scaffold a repo
vibe init # writes vibe.toml + playbooks/ + a sample plan
# sanity-check your setup
vibe doctor # adapters installed? creds resolve? CLIs on PATH?
# see how your plan would route — before spending a cent
vibe plan # prints the role + model chosen for every task
vibe run --dry-run # full routing + gating preview, no model dispatch
# go for real (watch it live in another pane)
vibe run &
vibe watch # tail the live log
vibe ledger # what actually happened
vibe cost # where the money went, by role + model + taskA plan is just markdown. Pin a role, or leave it blank and let the conductor decide:
## STEP 1 — Ship it
- [ ] 1.1 role: quick Fix the typo in the README header
- [ ] 1.2 role: dev Add input validation to the config loader
- [ ] 1.3 Refactor the retry policy for concurrency safety ← auto-routedpick task ─▶ ground spec ─▶ resolve role ─▶ fresh session ─▶ stream events ─▶ bus ─▶ you
▲ │
│ worker signals done
│ │
next task ◀─ ledger ◀─ commit / rollback ◀─ fast gate ◀──────────╯
│
(phase boundary?) ─▶ full gate ─▶ ledger
The core is small. Four plug-in points carry the weight — all discovered via Python entry points, so anyone can ship their own as a separate package:
- Adapters wrap a CLI → normalize its output to one event schema.
- Gates verify (lint / types / tests / any command). Fast per task, full per phase.
- Channels render the event stream (tail / TUI / web / jsonl / webhook).
- Memory stores durable, in-repo, reviewable knowledge + the ledger.
v0.1 — the engine is live and green. ✅
The whole loop works today: parse a plan, route each task (pin or auto), dispatch a worker, gate it, commit or roll back to baseline, ledger it, total the cost — all streaming to a live log. Ships with the claude-code adapter (native NDJSON) and generic-exec (wrap anything). ruff + mypy --strict clean, 26 tests green, CI passing.
v0.1 ✅ engine · role routing · cost capture · claude-code + generic-exec · gates · ledger · tail
v0.2 ▢ full worker pool · per-worker credential isolation · escalation · budgets · worktrees · vibe doctor parity
v0.3 ▢ visibility surfaces — Textual TUI · FastAPI web dashboard · replay
v0.4 ▢ more adapters — codex · aider · gemini-cli · opencode · goose · api-direct
v0.5 ▢ memory & context depth · spec templates · resume/salvage
v0.6 ▢ verification depth — adversarial verify panels · judge panels · phase-RED bisect
v1.0 ▢ frozen plug-in API · adapter marketplace · docs site
The full story — vision, the cost-routing model, architecture, the locked & researched tech stack, the field lessons, and the build plan — lives in one place:
Vibe Terminal doesn't reinvent the agent. It harnesses the ones you already pay for and adds the discipline they're missing: spec grounding, fresh-context dispatch, phased verification, git-level rollback, credential isolation, deliberate cost routing, and live visibility.
LangGraph / CrewAI / AutoGen build agents from API primitives. Vibe Terminal goes the other way — it treats finished CLI agents as interchangeable workers behind a uniform adapter. No rewrite. Just wrap and conduct.
Set the tempo. Let the ensemble play. 🎼
Apache-2.0 · built in the open · docs/00-BUILD-PLAN.md