Early access · 2026

The control loop for AI work.

Catch expensive sessions before they run. Find the waste hiding in the ones that succeed. Tie every session to whether the work was worth it.

On developer laptops (Claude Code, Cursor, Codex) and inside your product (one line per LLM call).

$ pip install aiwatcher-cli
Spend, sessions, outcomes, and risk at a glance
AI Spend
$43.39+95.2%
+95.2% vs prior
Sessions
4.6k
16 active
Useful Outcomes
1,342
live
High Risk
3
12 open alerts
Runaway spend, caught in real time
Spend, Sessions, and Risk TrendAnomaly
800600400200005-2506-0106-0806-1506-22
Cost by model, feature, and customer
Cost by Model
claude-sonnet-4-6
claude-opus-4-6
claude-haiku-4-5
gpt-4o
Cost by Product Feature
prospect-discovery
pipeline-cron
inbox-sync
reply-management

The AI bill jumped. Nothing broke. Nobody can say which feature or which agent did it.

Here’s where it goes.

On a developer’s laptop

A task, phrased loosely. Twenty turns of drift-and-redirect. The code works, and nobody looks because it succeeded — at 30x the tokens it needed.

In production

A feature got bumped to the premium model during an incident, and nobody switched it back. Retries succeed at triple the cost; one workflow takes forty steps instead of five for certain customers.

This is the part that changes the business, not just the budget. When cost moves with usage, every new customer is also a new cost, and gross margin stops being a fixed number you can plan around.

Every monitoring stack is built to watch for failure. This isn’t one.

Questions your engineering and product leads can’t answer this week:

Of the tokens we spent this week, how many were needed?
Which agent sessions produced code that survived, and which got reverted?
When the bill jumps, which feature, customer, or workflow drove it?

Two surfaces. One loop.

The five-step loop runs the same way on both surfaces. The install differs. The behavior is identical.

AIWatcher Local is free, open source, and yours alone. AIWatcher Enterprise runs the same loop on the AI inside your product, where what you track is customers, plans and features instead of sessions.

AIWatcher Local

Open source, free, forever

Every coding agent on every developer's machine.

  • Cost per commit, cost per line, and how much of that code is still alive a week later. Survival is measured by git blame in both directions, seven days after the commit, counting only lines you authored. It’s a floor, not an exact figure.
  • A receipt after every commit, rated against your own trailing median
  • Unbanked spend: the money that never reached a commit. Unbanked spend can’t tell abandoned exploration from work you haven’t committed yet. It’s a pointer, not a verdict.
  • Preflight scores prompts before the tokens are spent
  • Live cost and uncommitted spend in your Claude Code status line
  • Fresh-session handoffs when context bloats
  • Nothing leaves your machine. No account, no signup.

Install: pip install aiwatcher-cli. Zero code changes.

AIWatcher Enterprise

Enterprise

The same loop, across the organization.

The decision happens before the call does. AIWatcher checks the customer's plan and remaining allowance, then lets the request through or sends it to a cheaper model. The SDK confirms which model ran, and the receipt shows the cost and whether the customer accepted the result.

  • Checks the customer’s plan and allowance before the call runs, then lets it through or routes it to a cheaper model
  • Watch-only mode first, so you can see what a rule would have done before turning it on
  • A receipt for every decision: which rule fired, what it did, what ran, what it cost
  • Whether the cheaper path still gave the customer a good result
  • Spend by customer, plan, feature, app, team and workflow — and cost per success
  • Settles billing arguments with evidence. Your billing system still owns invoices.
  • Missing plan, allowance or outcome data is labelled, not guessed
  • Prompts and code stay on developer machines. Enterprise sees only metadata.
  • SSO and RBAC, retention, signed exports, team dashboards, Slack, Grafana and Datadog

Install: npm install aiwatcher. One line per LLM call.

AIWatcher Local is not a demo. It’s the full loop for one developer. Enterprise is what puts that loop in front of your customers’ AI calls, deciding before each one runs.

Pricing. AIWatcher Enterprise is an annual platform fee that scales with the applications under control and the AI usage behind them. We’re setting the number with our first design partners, so there’s no price list yet.

AIWatcher Local is free and open source. No cost, ever.

Where the loop intervenes

Named moments. Named moves.

A short list of moments AIWatcher watches for, on both surfaces, and what it does about each one.

On developer laptops

Loose prompt (PLAN)

Preflight scores a prompt as likely to wander the repo, offers a tighter brief with fewer files, and shows what the tighter version saved.

Context nearly full (WATCH)

Context is filling up with dead ends. AIWatcher writes a handoff brief — where you are, what you decided, what's next — so you restart clean instead of grinding on.

Destructive command (CONTROL)

Bulk delete, migration against live data, force push. Hard gate — Allow, Brief, or Cancel — across Claude Code, claude.ai, Codex, Cursor, and Claude Desktop.

Cost per surviving change (PROVE)

Every session linked to git: which ones produced commits, which changes survived the week, and what the surviving work cost. A floor, not an exact figure.

Which gates paid off (IMPROVE)

The loop records which briefs and gates led to cheaper, longer-surviving work, per repo and per developer. Patterns that keep getting caught are candidates for defaults.

Inside your product

Allowance nearly spent (CONTROL)

A Standard-plan customer starts an expensive workflow with most of the month's allowance gone. The rule checks before the call, sends it to the cheaper model, and the SDK confirms which model ran.

Cost per feature (WATCH)

Every LLM call tagged by feature at the wrap. The summarizer, the extraction pipeline, and the classifier show up as separate lines, not one bucket.

Cost per customer (WATCH)

Same wrap, customer_id in the productContext. The four accounts driving the majority of your inference spend rank themselves.

Retry inflation (WATCH)

A call that succeeds on the third attempt costs three times a clean one. It shows up as a gap between cost per request and cost per success, not a healthy line.

The success nobody checked (WATCH)

Nothing failed, so nothing flagged it. Spend is broken out by workflow and by success, not by call, so the expensive way to succeed separates from the cheap one.

Controls that pay off (IMPROVE)

The loop records which caps, model routes, and limits cut spend without hurting outcomes, so you can decide what's worth keeping. One-off fixes become candidates for policy defaults.

Why a loop, not another dashboard.

Your usage dashboards.

ccusage, vendor consoles, OTel exports. They tell you what happened after the money is spent, and they're built to investigate failures — not sessions that succeeded expensively.

Your gateway.

Blocks and routes API traffic on the one path routed through it. It never sees the coding agents on your developers’ laptops.

Your developers’ own vigilance.

Claude Code asks permission for every command, until people turn the prompts off. At most companies a human watching the terminal is the real control plan, and that defeats the point of agents.

AIWatcher replaces none of your observability and all of your blind spots.

PLAN

Score the prompt; rewrite loose ones into scoped briefs before a token is spent.

WATCH

Track context and quota; hand off cleanly when either runs out.

CONTROL

Gate destructive commands and looping sessions, across every tool, not inside one.

PROVE

Cost per successful outcome, not cost per token. Every commit gets a receipt: what it cost, what it produced, and how much of it was still there a week later. A floor, not an exact figure.

IMPROVE

Track which prompts, gates, and controls paid off, so the ones that work can become your defaults.

The same loop applies to the AI running in your product, via a one-line SDK per call.

The shift, in numbers

AI tooling went from a line item to a budget category in 18 months. Most teams have no instrumentation for it.

70%

of AI-native engineering teams now run 3+ AI models in production.

23% run 6+. Most have no per-model, per-team, or per-feature cost attribution today.

Source: Datadog, State of AI Engineering 2026

2 out of 3

of platform engineering and SRE leaders will own production AI systems by 2028.

Most aren't equipped to manage the cost and behavior side yet.

Source: Gartner, Innovation Insight: LLM Observability, July 2025

Why we built this: my own $400 lesson

“We ran five Claude Code agents on a thirty-second loop for a meeting-notes pipeline. It ran unattended for ten days: 31,762 session files, 6,352 dispatch cycles, about $400 in tokens. First signal was an email from Anthropic saying I’d burned through a budget that should have lasted months. The agents were doing exactly what I built them to do. A dashboard would have shown me the damage. A control loop would have stopped it on day one.”

Danny Lo, founder, AIWatcher

The math you can check yourself

One prevented runaway pays for the year. So does reclaiming 3 to 5% of what you’re already spending.

You don’t have to take our word for either. Both show up on the invoice you already get.

Built for teams with AI on both sides of the product: the agents helping write it, and the AI your customers use inside it.

Just the coding agents for now? AIWatcher Local is still free, still open source, and still yours.

Install AIWatcher Local

Free, open source, no account, nothing leaves your machine.

Install AIWatcher Local

Running AI at scale?

We’re taking on a small number of design partners for the organization-wide loop.

Tell us about your setup
Which coding agents does your team use?

We reply within 48 hours. No newsletter, no marketing automation. Just a real reply from one of us.