Flagship · open source · Python stdlib only

Every model lane, one frame

lanewatch is a btop-style terminal monitor for the model lanes you actually run: local inference servers (vLLM, llama.cpp, LM Studio) on your own hardware, and cloud assistant sessions (Claude Code, Codex) reconstructed from files already on your machine. One process, no daemon, no database, nothing beyond the Python standard library.

lanewatch rendering local inference servers and cloud assistant lanes in one frame: braille pulse graphs per lane, a spend burn bar, and a rolling activity log — The built-in --demo mode: synthetic data, no backend required. What you see is the real renderer; the numbers are staged.

How it stays honest about what it sees

Readings are numbers, never content

A reading is a flat dict of plain numbers plus a handful of short label fields. validate_reading() enforces that shape on every poll, and a test enumerates every Source subclass so the build fails if one ever bypasses it. The docs answer the privacy question completely.

api$: a counterfactual, not a bill

A separate panel prices your subscription usage at what it would cost at metered API list rates, per record, by that record's model, cache writes included. Unknown model ids render as unknown, never as free, and the price table is static and dated on screen. Codex sessions expose no token accounting in any file checked, so that lane shows a gap, not a zero.

Nothing to install, nothing phoning home

Python standard library, zero dependencies, one process. It reads local endpoints and local files and renders to your terminal; there is no server, no account, no telemetry.

Honest limits

The honest limits are the pitch, not a footnote under it.

Early, by its own README: the renderer and source contract are in place, backends are landing one at a time, and the test suite (400 tests and 52 subtests as of 2026-07-25) is the only claim of correctness this project makes.
api$ figures are estimates from a static, dated price table; prices drift and the screen says so. It is what your usage would cost at metered list prices, not what you actually pay.
Codex sessions expose no token accounting, so that lane shows a gap, not a zero dollar figure.
A cloud lane is a reconstruction from local session files: if a tool stops writing them, the lane goes quiet. lanewatch never phones anywhere to check.

Where it came from

lanewatch began as a fork of vllm_breath (also published as GOLEM BREATH), a single-file btop-style vLLM monitor credited to HERETICAL TANDEM (Viktor Zhuromsky and Prometheus^2), shared publicly by its author with an explicit invitation to build on it. The rendering engine (braille plotting, diff rendering, panel collapse, Prometheus parsing) is that upstream lineage.

The source contract and privacy wall, the field vocabulary, the cloud-lane backends, the pricing panel, and the panel model are new in this fork. The full lineage note is the whole story, credit included; the license is MIT for the parts authored here, with a scope note covering the unlicensed upstream.

Built like it says on the tin

Terminal escape injection (a hostile label from an HTTP response is stripped so it cannot leave the alt screen or repaint your terminal) and bounded HTTP reads (an 8 MiB cap) are both security-reviewed and regression-tested in the repo. GPU telemetry reads Intel Arc (Battlemage, the xe driver) via hwmon and per-process fdinfo, which i915-era tools cannot see, plus NVIDIA via nvidia-smi; memory renders as an absolute value, not a fake percentage, because xe exposes no VRAM total. The visuals are braille pulse sparklines per lane, a spend burn bar filling toward an auto-rescaling ceiling, and a rolling in-memory activity log.

Run it

Python 3, nothing to pip install.

Clone the repo.
Run ./bin/lanewatch to auto-discover your local lanes.
Or run ./bin/lanewatch --demo to see it with synthetic data and no backend at all.

See the code on GitHub → Or ask a question