# Your MCP server's tool calls are silently burning money. Here's a 40-line budget guard.

> Source: <https://dev.to/renev3408/your-mcp-servers-tool-calls-are-silently-burning-money-heres-a-40-line-budget-guard-5gkl>
> Published: 2026-10-19 02:07:56+00:00

Your MCP server's tool calls are silently burning money. Here's a 40-line budget guard.

You have 3 agents running in parallel, each calling the same expensive LLM tool 50 times per minute. The first agent finishes its batch and stops. The second and third agents keep calling until their 10-minute time budget expires. By then you've spent $47 on a job that should have cost $12.

This happens because MCP tool calls are fire-and-forget: you send the request, you get a result, and you never track how much you've spent. No per-call budget, no time limit, no per-agent cap.

Here's a 40-line budget guard that stops runaway tool calls in their tracks.

An MCP server exposes a tool like this:

```
{
  "name": "llm_generate",
  "description": "Generate text using an LLM",
  "inputSchema": {
    "type": "object",
    "properties": {
      "prompt": { "type": "string" },
      "model": { "type": "string", "enum": ["gpt-4", "claude-3-5-sonnet"] }
    }
  }
}
```

Your agent calls it like this:

``` js
const result = await client.callTool({
  name: "llm_generate",
  arguments: { prompt: "Write a Python script to..." }
});
```

No budget, no time limit, no per-agent cap. If the agent loops 100 times, you pay for 100 calls.

Wrap the tool call in a budget guard that tracks:

``` js
// budget-guard.js
import { EventEmitter } from "events";

class ToolCallBudgetGuard {
  constructor(options = {}) {
    this.timeBudget = options.timeBudget || 10 * 60 * 1000; // 10 minutes
    this.tokenBudget = options.tokenBudget || 10_000;
    this.costPerToken = options.costPerToken || 0.00003; // GPT-4 ~$3/1M tokens
    this.budgets = new Map(); // agentId -> { timeUsed, tokensUsed, startTime }
    this.emitter = new EventEmitter();
  }

  // Get or create a budget for an agent
  getBudget(agentId) {
    if (!this.budgets.has(agentId)) {
      this.budgets.set(agentId, {
        timeUsed: 0,
        tokensUsed: 0,
        startTime: Date.now()
      });
    }
    return this.budgets.get(agentId);
  }

  // Check if a tool call is allowed
  canCall(agentId, estimatedTokens = 0) {
    const budget = this.getBudget(agentId);
    const timeUsed = Date.now() - budget.startTime;
    const tokensUsed = budget.tokensUsed + estimatedTokens;

    const timeExceeded = timeUsed > this.timeBudget;
    const tokensExceeded = tokensUsed > this.tokenBudget;

    if (timeExceeded || tokensExceeded) {
      this.emitter.emit("budgetExceeded", {
        agentId,
        reason: timeExceeded ? "time" : "tokens",
        timeUsed,
        tokensUsed
      });
      return false;
    }

    return true;
  }

  // Record a successful tool call
  recordCall(agentId, tokens = 0, cost = 0) {
    const budget = this.getBudget(agentId);
    budget.timeUsed = Date.now() - budget.startTime;
    budget.tokensUsed += tokens;
    budget.cost += cost;

    this.emitter.emit("callRecorded", {
      agentId,
      tokens,
      cost,
      timeUsed: budget.timeUsed,
      tokensUsed: budget.tokensUsed
    });
  }

  // Get current budget usage
  getUsage(agentId) {
    const budget = this.budgets.get(agentId);
    if (!budget) return null;
    return {
      timeUsed: Date.now() - budget.startTime,
      tokensUsed: budget.tokensUsed,
      cost: budget.cost
    };
  }
}

export default ToolCallBudgetGuard;
python
import ToolCallBudgetGuard from "./budget-guard.js";

const guard = new ToolCallBudgetGuard({
  timeBudget: 10 * 60 * 1000, // 10 minutes
  tokenBudget: 10_000,
  costPerToken: 0.00003 // GPT-4
});

// Listen for budget exceeded events
guard.on("budgetExceeded", ({ agentId, reason, timeUsed, tokensUsed }) => {
  console.error(`[${agentId}] Budget exceeded: ${reason}`);
  console.error(`  Time used: ${Math.round(timeUsed / 1000)}s`);
  console.error(`  Tokens used: ${tokensUsed}`);
});

// Wrap your tool call
async function callLLM(agentId, prompt, model = "gpt-4") {
  // Estimate tokens (simplified: 4 chars per token for English)
  const estimatedTokens = Math.ceil(prompt.length / 4);

  // Check budget before calling
  if (!guard.canCall(agentId, estimatedTokens)) {
    throw new Error(`Tool call blocked: budget exceeded for ${agentId}`);
  }

  // Call the LLM
  const result = await openai.chat.completions.create({
    model,
    messages: [{ role: "user", content: prompt }]
  });

  // Record the call
  guard.recordCall(agentId, result.usage.total_tokens, result.usage.total_tokens * guard.costPerToken);

  return result.choices[0].message.content;
}

// Use it in your agent
const agent1 = callLLM("agent-1", "Write a Python script...");
const agent2 = callLLM("agent-2", "Write a Python script...");
const agent3 = callLLM("agent-3", "Write a Python script...");
```

`length / 4`
`llm_generate`) separately from others.
Runaway tool calls are a silent budget killer. A 40-line guard stops them before they burn you.

*This article is a teaching piece. For a production-ready MCP tool-call budgeting pack, see the linked resources above.*