Coming next — no public package yet
Know what's left
in the tank.
Tank is resource intelligence for AI agents and agent fleets: it meters real usage, forecasts what a task will cost, and gates automation before it burns through your subscription limits.
A fuel gauge that lies is worse than no gauge. Tank's first rule is honesty.
Deliberate fast-follow to Null + Aleph, in live calibration on our own fleet now — target early August. Apache-2.0 like everything else we ship.
The problem: your limits are opaque
Subscription AI plans meter you in windows you can't see into — weekly caps, session caps, per-model pools that reset on their own schedules. A single agent burning through them mid-task is annoying. A fleet of agents doing overnight work against invisible limits is how you wake up to six stalled seats and no idea which window emptied first.
The question Tank answers is the one every operator actually asks: “Can I start this run, or will it hit the wall?”
Meter · Forecast · Gate
Meter
Ingests your real usage transcripts into a local store — every request weighted by what it actually consumed, labeled by task class and session. No cloud, no telemetry leaving your machine.
Forecast
Learns what a task class costs as quantiles — p50, p80, p95 — from your own labeled history, not vendor averages. An overnight grind session and a quick review have very different price tags; Tank knows both.
Gate
Before automation starts: budget = ceiling − consumed − reserve, where the reserve is a fraction of the ceiling held back for interactive work. If the task's p80 estimate fits the budget, GO. If it doesn't, WAIT with a suggested retry. If the ceiling is unknown, it says ADVISORY — honestly — instead of inventing a number.
Any model. Any machine. One fuel state.
Tank was built for a fleet that runs Claude, Grok, Gemini, and Cursor seats side by side, on macOS, Windows, and Linux. It works for all of them the same way: the gauge is exposed as MCP tools — status, estimate, gate — that any MCP-speaking agent can call, whatever model is behind it.
Snapshots publish over the org's vendor-neutral exchange, so a Gemini seat can see how much fuel the Claude pool has left before it hands work across, and the whole fleet steers by one shared picture instead of six private guesses. Different LLMs, different architectures — in harmony because the protocol is the common tongue.
Built honest, because we steer by it
Tank exists because we run a multi-seat fleet against real subscription limits and got tired of guessing. Every principle below is a scar, not a slogan.
UNKNOWN over invented numbers
If Tank hasn't seen enough real limit episodes to trust a ceiling, it reports UNKNOWN and gates advisory — it never fabricates remaining fuel. Confidence is earned from data, not assumed.
Ceilings are learned or declared, never guessed
Tank learns your true caps from actual limit-hit episodes, and you can explicitly seed a ceiling you know. Either way the number has a source you can audit — no vendor-brochure arithmetic.
The estimator audits itself
Tank measures its own honesty: live estimates are compared against full-session ground truth, and a drifting estimator is a bug to fix, not a number to ship. We caught our own gauge reading 3× low and rebuilt the labeling until live ≡ truth.
Per-vendor, per-window gauges
Different vendors meter in different units over different windows — weekly token pools, request counts, session caps. Tank models each gauge in its own shape instead of flattening everything into one fake number.
Account-level, not per-seat
Limits bind to your account, not to one agent. Tank treats the account as the unit: multiple seats on one machine, one seat's gauge shared across a fleet — the pool is what empties, so the pool is what's measured.
Fleet-visible over the exchange
Gauge snapshots publish to your org's exchange so every seat sees the same fuel state before starting work — and the telemetry survives even when the seat that reads a meter goes dark. We learned that one live.
Where it stands
Tank is running today as the fuel gauge for our own six-seat fleet — metering live usage, labeling real sessions, and gating our own overnight automation. It is in active calibration: we don't ship an estimator until it has proven honest against our own consumption.
It lands as a deliberate fast-follow after Null and Aleph — target early August, free and open source under Apache-2.0. No public install yet; when there is one, it will be announced here.