Your cost dashboard tells you what you spent. RunGuard stops the run that is actively spending it.

import { guard, BudgetExceededError } from "@runguard/sdk";
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

// Token prices (USD per million tokens) as of 2026
const PRICES = {
  "claude-sonnet-4-6": { input: 3, output: 15 },
  "claude-opus-4-7": { input: 15, output: 75 },
};

async function callClaude(
  model: keyof typeof PRICES,
  messages: Anthropic.MessageParam[]
) {
  const response = await client.messages.create({
    model,
    max_tokens: 4096,
    messages,
  });
  const p = PRICES[model];
  const usd = (response.usage.input_tokens * p.input + response.usage.output_tokens * p.output) / 1_000_000;
  const sig = response.content[0].type === "tool_use" ? response.content[0].name : "end_turn";
  return { response, usd, sig };
}

const guarded = guard(callClaude, {
  budget: { maxUsd: 5 },
  loop: { repeats: 3, maxCycleLen: 8 },
});

// In your agent loop:
async function runAgent(task: string) {
  const messages: Anthropic.MessageParam[] = [{ role: "user", content: task }];

  while (true) {
    try {
      const { response } = await guarded("claude-sonnet-4-6", messages);

      if (response.stop_reason === "end_turn") break;

      // process tool calls and append results
      messages.push({ role: "assistant", content: response.content });
      // ... append tool results ...

    } catch (e) {
      if (e instanceof BudgetExceededError) {
        console.error(`Run aborted: spent $${e.spent.toFixed(4)}, cap was $5.00`);
        // notify on-call, log to analytics, or fail gracefully
        return { status: "budget_exceeded", spent: e.spent };
      }
      throw e;
    }
  }
}

import asyncio
from runguard import guard, guard_async, BudgetExceededError
import anthropic

client = anthropic.AsyncAnthropic()

PRICES = {
    "claude-sonnet-4-6": (3, 15),     # input, output USD/1M tokens
    "claude-opus-4-7": (15, 75),
}

async def call_claude(model: str, messages: list) -> dict:
    response = await client.messages.create(
        model=model,
        max_tokens=4096,
        messages=messages,
    )
    p_in, p_out = PRICES[model]
    usd = (response.usage.input_tokens * p_in + response.usage.output_tokens * p_out) / 1_000_000
    sig = response.content[0].name if response.stop_reason == "tool_use" else "end_turn"
    return {"response": response, "usd": usd, "sig": sig}

guarded = guard_async(
    call_claude,
    budget={"max_usd": 5},
    loop={"repeats": 3},
)

async def run_agent(task: str) -> dict:
    messages = [{"role": "user", "content": task}]

    while True:
        try:
            result = await guarded("claude-sonnet-4-6", messages)
            response = result["response"]

            if response.stop_reason == "end_turn":
                return {"status": "complete", "output": response.content}

            # process tool calls
            messages.append({"role": "assistant", "content": response.content})
            # ... append tool results ...

        except BudgetExceededError as e:
            return {
                "status": "budget_exceeded",
                "spent": e.spent,
                "message": f"Run aborted at ${e.spent:.4f} (cap: $5.00)",
            }