Passive Cost Memory for Agent Development

MCPAI代理

提供方 RaleighSF

AI代理 未标注 会话登录 社区 / 第三方 ClaudeCursorGemini CLICodex

Burnwatch detects every paid service in your project, tracks spend across 14 AI-native tools (Anthropic, OpenAI, Vercel, Supabase, Stripe, Scrapfly, Browserbase, and more), and exposes real-time cost data via MCP tools — so any LLM can factor budget into its recommendations. Four

一句话选型结论

按资料字段整理

Passive Cost Memory for Agent Development 属于AI代理类 MCP 服务器,传输方式未标注,会话登录,可直接接入 Claude、Cursor、Gemini CLI 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式未标注 鉴权会话登录 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

cost tracking billing finops budget saas developer tools anthropic openai

支持客户端

适用场景

cost trackingbillingfinops

安装与配置

未标注 会话登录
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude、Cursor、Gemini CLI,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Passive Cost Memory for Agent Development当前 未标注 未标注 未标注 无 未标注
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方RaleighSF上游标注的维护方 RaleighSF
分类AI代理本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

16.9 KB
来自项目仓库与上游目录的原文,未做删改

burnwatch

You're coding 10x. You might also be spending 10x.

Passive cost memory for AI-assisted development.```
╔══════════════════════════════════════════════════════════════
║ BURNWATCH — your-app — March 2026
╠══════════════════════════════════════════════════════════════
║ Service Spend Conf Budget Left
║ ──────────────────────────────────────────────────────────
║ anthropic $47.20 ✅ LIVE $100 53%
║ vercel $20.00 🟡 CALC $20 flat — on plan
║ scrapfly $127.00 ✅ LIVE $100 ⚠️ OVER
║ browserbase ~$12.40 ✅ LIVE $99 87%
║ supabase $25.00 🟡 CALC $25 flat — on plan
║ posthog $0.00 🟡 CALC $0 —
║ ↳ 234K/1M events (23%)
╠══════════════════════════════════════════════════════════════
║ TOTAL: ~$231.60 Untracked: 0 ✅ Est margin: ±$12
║ 🚨 scrapfly 127% OVER BUDGET - review before use
╚══════════════════════════════════════════════════════════════


This shows up automatically. Every session. No dashboards to check. No tabs to remember. Just quiet awareness right where you're already working.

## The Problem

Here's how it usually goes.

You're deep in a flow state. Claude is writing features, you're approving them, the codebase is growing, and everything feels amazing. Tuesday you add a Scrapfly key for web scraping. Wednesday you wire up Browserbase for browser automation. By Friday your agent has built a cron job that scrapes 1,000 competitor pages every other day. The code works perfectly.

Three weeks later the bill shows up. Turns out "works perfectly" costs $340/month and you signed up for the $99 plan.

This is the new normal with AI-assisted development. The services that charge you are getting wired in by an agent that has zero concept of what they cost. It doesn't know that Scrapfly's anti-bot bypass burns 25x your base credits. It doesn't know that Anthropic Opus costs 15x more per token than Haiku. It doesn't know you're on the free tier with a hard cap at 1,000 API calls.

And the sneaky part? Most of these services look cheap when you sign up. $20/month. $99/month. Flat fee, no worries. But then there's the overage rate buried on page three of the pricing docs. You leave the signup page feeling good about $20 and come back to a monthly bill in the hundreds because you blew past the included usage and nobody told you.

**78% of IT leaders experienced unexpected charges** tied to consumption-based or AI pricing in the past 12 months (Zylo 2026 SaaS Management Index).

burnwatch sits between your agent and your wallet. It watches every file save, knows every billing model, and speaks up before the damage is done.

## Install```bash
npx burnwatch init

That's it. burnwatch scans your project, detects paid services, and registers hooks. Next session, you see your spend.

> Requirements: Node.js 18+ · Works with Claude Code, MCP, or standalone CLI

How It Works

1. Detection

You run npx burnwatch init and burnwatch immediately scans four surfaces:

What it checks Example When
package.json "@anthropic-ai/sdk" in dependencies Init, file change
Environment variables SCRAPFLY_KEY in .env Every session start
Import statements import { Resend } from "resend" Init, file change
Prompt mentions "use Browserbase to scrape..." Every prompt
🔍 Scanning project for paid services...

   Found 6 paid services:

   ● Anthropic (Claude)        ✅ LIVE API available
     Detected via: package.json, env vars, imports
   ● Scrapfly                  ✅ LIVE API available
     Detected via: env vars, imports
   ● Browserbase               ✅ LIVE API available
     Detected via: package.json, imports
   ● Supabase                  ✅ LIVE API available
     Detected via: package.json, env vars
   ● Vercel                    🟡 Flat plan
     Detected via: package.json
   ● PostHog                   🟡 Free tier
     Detected via: package.json, imports

🔗 Registering hooks...
✅ burnwatch initialized!

2. The Interview

No CLI flags. No YAML config files. You just talk to your agent:```
You: "Let's set up burnwatch for this project"


Your agent runs a conversational interview, walking through each service by risk category (LLMs first, then usage-based, then flat infrastructure):```
Agent: I found 6 services. Let me walk through each one.

       Anthropic — I probed your API key. You're on API Usage,
       $47.23 spent this billing period. Default budget: $100/mo.
       Does that feel right?

You:   Yeah that's fine.

Agent: ✅ Anthropic set to $100/mo budget.

       Scrapfly — Probe detected Pro plan (1M credits).
       You've used 742K/1M credits. Budget: $100/mo.

You:   Keep it.

Agent: ✅ Scrapfly set to Pro, $100/mo.

       Vercel — You're on Pro ($20/mo flat).
       PostHog — Free tier.
       I'll set these as flat plans with matching budgets.
       Skip?

You:   Yep.

Agent: ✅ Vercel $20, PostHog $0 — all set.

Each answer is written back immediately. The whole thing takes about 90 seconds.

3. Billing Manifests

This is where it gets interesting. Every tracked service has a billing manifest, a community-maintained JSON file that encodes the complete pricing model:```json
{
"serviceId": "browserbase",
"billingDimensions": [
{
"id": "browser_hours",
"name": "Browser hours",
"unit": "hour",
"ratePerUnit": 0.10,
"ratePer": 1,
"variants": [
{ "id": "standard", "ratePerUnit": 0.10, "codePatterns": ["createSession"] }
]
},
{
"id": "proxy_bandwidth",
"name": "Proxy bandwidth",
"unit": "GB",
"ratePerUnit": 10.00,
"ratePer": 1
}
],
"plans": [
{ "id": "startup", "monthlyBase": 99, "included": { "browser_hours": 500 } }
],
"costMultipliers": [
{ "id": "long_session", "factor": 10, "codePatterns": ["keepAlive", "waitForTimeout"] }
]
}


This is not guesswork. burnwatch knows that Browserbase charges per browser-hour (not per session), that the Startup plan includes 500 hours, that overages are $0.10/hr, and that long-running sessions with `keepAlive` can multiply cost by 10x. It knows that Anthropic Opus costs 5x more than Sonnet. It knows that Scrapfly's anti-bot bypass burns 5-25x base credits.

12 services ship with production-verified manifests. Adding a new one is a single JSON file.

### 4. Passive Monitoring

You code. burnwatch watches. Every time a file is saved, three things happen silently:

**Cost impact analysis** scans the changed file for SDK call sites, detects multipliers (loops, `.map()`, `Promise.all`, cron schedules), resolves variable loop bounds, matches model variants in the code, and projects monthly cost:```
[BURNWATCH] ⚠️ Cost impact estimate for scraper.ts
  Browserbase: ~15,000 calls/mo → $37-$375/mo (Long-running sessions)
  Current: $12/$99 budget (12%)

Utilization tracking updates incrementally, tracking every call site across the project and projecting overage:```
[BURNWATCH] ⚠️ Browserbase utilization: ~750 browser-hours/mo
(plan includes 500) → ~$25.00/mo overage


**New service detection** fires if a file change introduces something burnwatch hasn't seen before:```
[BURNWATCH] 🆕 New paid service detected: twilio
  Run 'burnwatch add twilio' to configure budget and tracking.

5. Intervention (The Part That Actually Saves You Money)

Here's the scenario that matters. You're five sessions and 4,000 lines deep. You tell Claude to build a web scraper:```
You: "Create a scraper that uses Browserbase to scrape 1000 competitor
pages every other day on a cron job"


Claude writes the code. The moment the file is saved, burnwatch fires:```
[BURNWATCH] ⚠️ Cost impact estimate for scraper.ts
  Browserbase: ~15,000 sessions/mo → $37-$375/mo (Long-running sessions)
  Current: $12/$99 budget (12%)

[BURNWATCH] ⚠️ Browserbase utilization: ~750 browser-hours/mo
  (plan includes 500) → ~$25.00/mo overage

Claude sees this in its own context, injected as a system message. It doesn't wait for you to ask about cost. It responds proactively:```
Agent: I built the scraper, but heads up — burnwatch flagged this:

   At 1,000 pages every other day, you're looking at ~750
   browser-hours/month. Your Startup plan includes 500 hours,
   so you'd hit ~$25/mo in overage on top of the $99 base.

   A few options:
   1. Reduce to 500 pages per run (stays within plan)
   2. Use Playwright locally for non-JS pages (free)
   3. Batch into fewer longer sessions to reduce overhead

   Want me to adjust?

**That conversation does not happen without burnwatch.** Without it, Claude writes the scraper, you ship it, and you find out about the overage three weeks later when the bill shows up. By then the cron job has been happily running the whole time.

## Multiplier Detection

burnwatch doesn't just count API calls. It reads the code structure around them.

| Pattern | Example | Detection |
|---------|---------|-----------|
| **Literal loop bounds** | `for (let i = 0; i < 1000; i++)` | Factor: 1000 |
| **Variable loop bounds** | `const PAGES = 1000; for (i < PAGES)` | Resolves `PAGES` to 1000 |
| **Array iteration** | `urls.map(async (u) => scrape(u))` where `urls = Array(500)` | Factor: 500 |
| **for...of** | `for (const page of pages)` where `pages` has known size | Resolved size |
| **Promise.all** | `Promise.all(urls.map(...))` | No double-count with `.map()` |
| **Named constants** | `const NUM_REQUESTS = 5000` | Detected as multiplier hint |
| **Cron: every 5 min** | `// every 5 minutes` or `*/5 * * *` | Factor: 8640/mo |
| **Cron: every other day** | `// every other day` or `*/2` | Factor: 15/mo |
| **Cron: weekly** | `// every week` or `0 0 * * 0` | Factor: 4/mo |
| **Batch size** | `const batch_size = 50` | Factor: 50 |

When a billing manifest has **cost multipliers** with code patterns (like Scrapfly's `asp.*true` for anti-bot bypass), those get detected too, giving you a cost range instead of a single number.

## Confidence Tiers

Every spend figure carries a confidence badge. burnwatch never pretends to know more than it does.

| Badge | Meaning | Source |
|-------|---------|--------|
| ✅ **LIVE** | Real billing API data | Polls service API with your key |
| 🟡 **CALC** | Fixed monthly cost | You enter your plan cost |
| 🟠 **EST** | Instrumented estimate | Usage signals + pricing formula |
| 🔴 **BLIND** | Detected, not tracked | Service exists but no config |

The brief always shows the untracked count. You never get a clean-looking dashboard hiding a surprise.

## Supported Services

| Service | Tier | Billing Model | The Thing That Gets You |
|---------|------|--------------|------------------------|
| Anthropic | ✅ LIVE | Per-token | Opus is 15x more per token than Haiku. Your agent picks models. |
| OpenAI | ✅ LIVE | Per-token | GPT-4o-mini is 66x cheaper than o1. Model choice matters a lot. |
| Scrapfly | ✅ LIVE | Credit pool | Anti-bot bypass burns 5-25x base credits. Silently. |
| Browserbase | ✅ LIVE | Per browser-hour | Charged by time, not sessions. Long sessions cost more. |
| Vercel | ✅ LIVE | Compute + overages | Function GB-hours is the #1 surprise on Vercel bills. |
| Supabase | ✅ LIVE | Tiered + overages | Database size grows fast with vector embeddings. |
| Google Gemini | 🟡 CALC | Per-token | Generous free tier, but Flash 2.0 is so cheap people forget to check. |
| Voyage AI | 🟡 CALC | Per-token | Embedding-only. Cost scales with corpus size, not query count. |
| Upstash | 🟠 EST | Per-command | $0.20/100K commands. Free tier: 10K/day. Easy to forget it's metered. |
| Resend | 🟠 EST | Per-email | $0.90/1K emails overage on Pro. Fine until your app goes viral. |
| Inngest | 🟡 CALC | Per-execution | Runs AND steps both count. A 5-step function is 6 executions. |
| PostHog | 🟡 CALC | Per-event | 1M events/mo free. That sounds like a lot until it isn't. |

## Billing Manifests

The `billing/` directory contains one JSON file per service. Each manifest encodes:

- **Billing dimensions**: every axis the service charges on (tokens, sessions, bandwidth, etc.)
- **Variants**: per-model rates with regex code patterns for auto-detection (Haiku vs Sonnet vs Opus)
- **Plans**: what's included, overage rates, hard caps
- **Cost multipliers**: feature flags that multiply cost (anti-bot bypass, JS rendering, stealth mode)
- **Typical dev usage**: realistic usage patterns for smarter projections

### Adding a new service

Drop a JSON file in `billing/`:```json
{
  "$schema": "./billing.schema.json",
  "serviceId": "my-service",
  "name": "My Service",
  "lastVerified": "2026-03-25",
  "pricingUrl": "https://my-service.com/pricing",
  "billingDimensions": [
    {
      "id": "api_calls",
      "name": "API calls",
      "unit": "call",
      "ratePerUnit": 1.00,
      "ratePer": 1000
    }
  ],
  "plans": [
    {
      "id": "pro",
      "name": "Pro ($29/mo)",
      "monthlyBase": 29,
      "included": { "api_calls": 50000 },
      "overageRates": { "api_calls": 1.00 }
    }
  ]
}

No code changes needed. The cost engine picks it up automatically.

MCP Server

burnwatch ships an MCP server for use with any MCP-enabled LLM:```bash
claude mcp add burnwatch -- node ./node_modules/burnwatch/dist/mcp-server.js


**Tools exposed:**

| Tool | Purpose |
|------|---------|
| `get_spend_brief` | Full spend table with alerts |
| `get_service_spend` | Detailed info for one service |
| `analyze_cost_impact` | Analyze a file for cost-impacting SDK calls |
| `get_utilization` | Project-wide utilization and overage projections |
| `get_billing_manifest` | Raw billing manifest for any service |
| `detect_paid_services` | Scan for paid services in a project |
| `list_registry_services` | All services in the registry |

## Claude Code Integration

burnwatch runs as Claude Code hooks, background scripts that fire on session lifecycle events:

| Hook | Event | What it does |
|------|-------|-------------|
| **Session start** | New or resumed session | Polls billing APIs, renders the spend brief |
| **Prompt submit** | You type a prompt | Detects service mentions, injects spend cards |
| **File change** | Code is written/edited | Cost impact analysis, new service detection, utilization update |
| **Session stop** | Session ends | Writes the spend ledger to disk |

burnwatch also installs three **agent skills**:

- `/setup-burnwatch`: Guided onboarding
- `/burnwatch-interview`: Conversational service-by-service configuration
- `/spend`: Quick spend check (or `/spend scrapfly` for one service)

## CLI Reference```
burnwatch init                              Initialize in current project
burnwatch setup                             Init + auto-configure all detected services
burnwatch add <service> [options]           Register a service for tracking
burnwatch configure [options]               Update service config (plan, budget, key)
burnwatch interview --json                  Export current state as JSON (for agent use)
burnwatch status                            Show current spend brief
burnwatch scan                              Full project utilization scan
burnwatch services                          List all services in registry
burnwatch reconcile                         Scan for untracked services
burnwatch version                           Show version

Config & Security

Credentials never live in your project directory.```
~/.config/burnwatch/
config.json API keys, tokens (chmod 600, never in git)

your-project/.burnwatch/
config.json Services, budgets, detection history
spend-ledger.md Human-readable spend report (git-committable)
data/
utilization.json Code-derived usage projections
events.jsonl Append-only event log
cache/ Billing API response cache
snapshots/ Point-in-time spend snapshots
```

Contributing

The fastest way to contribute: add a billing manifest.

  1. Fork the repo
  2. Create billing/.json following billing/billing.schema.json
  3. Include billing dimensions, plans, and ideally cost multipliers
  4. Verify rates against the service's pricing page
  5. Open a PR

You can also add services to registry.json with detection patterns, or improve the cost-impact multiplier detection.

License

MIT

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Passive Cost Memory for Agent Development 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Passive Cost Memory for Agent Development 怎么在 Claude、Cursor、Gemini CLI 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Passive Cost Memory for Agent Development 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Passive Cost Memory for Agent Development 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

Passive Cost Memory for Agent Development 支持哪些客户端?

资料标注支持 Claude、Cursor、Gemini CLI、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Passive Cost Memory for Agent Development 能提供哪些能力?

资料显示能力标签包括 cost tracking、billing、finops、budget、saas、developer tools。具体工具清单以官方文档为准。

Passive Cost Memory for Agent Development 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。