Cost Tracking and Budget Limits for LangGraph Agents

[bmdhodl]

LangGraph lets you build stateful, multi-step agents as graphs. But there's no built-in way to track how much a graph execution costs or kill it when it exceeds a budget.

Here's how to add per-execution cost tracking and hard budget limits to any LangGraph agent.

The problem

A LangGraph agent with multiple nodes can make many LLM calls per execution. Each node might call GPT-4, and a complex graph can loop through nodes multiple times. Without tracking, you have no idea what a single execution costs until you check your OpenAI dashboard.

Solution: guarded_node wrapper

AgentGuard's LangGraph integration wraps individual nodes with budget and loop guards:

from langgraph.graph import StateGraph, END
from agentguard import Tracer, BudgetGuard, LoopGuard, JsonlFileSink
from agentguard.integrations.langgraph import guarded_node

# Set up guards
tracer = Tracer(
    sink=JsonlFileSink("traces.jsonl"),
    service="my-langgraph-agent",
    guards=[
        BudgetGuard(max_cost_usd=5.00, warn_at_pct=0.8),
        LoopGuard(max_repeats=3),
    ],
)

# Define your graph
graph = StateGraph(AgentState)

# Wrap nodes — guards check after each node execution
graph.add_node("research", guarded_node(research_fn, tracer))
graph.add_node("analyze", guarded_node(analyze_fn, tracer))
graph.add_node("write", guarded_node(write_fn, tracer))

graph.add_edge("research", "analyze")
graph.add_edge("analyze", "write")
graph.add_edge("write", END)

app = graph.compile()
result = app.invoke({"input": "Research quantum computing trends"})

What guarded_node does

1. Creates a trace span for each node execution
2. If the node makes LLM calls (via patched OpenAI/Anthropic), tracks token usage and cost
3. After each node, checks all guards (budget, loops, timeout)
4. Raises BudgetExceeded or LoopDetected to stop the graph

Checking costs after execution

The trace output in traces.jsonl includes cost data for every span:

agentguard report traces.jsonl

This gives you a breakdown of cost per node, total execution cost, and token counts.

Guard node (alternative pattern)

Instead of wrapping every node, you can add a single guard checkpoint node:

from agentguard.integrations.langgraph import guard_node

graph.add_node("budget_check", guard_node(tracer))

# Add edges so the guard runs between expensive nodes
graph.add_edge("research", "budget_check")
graph.add_edge("budget_check", "analyze")

This is useful when you only want to check budgets at specific points in the graph.

Install

pip install agentguard47[langgraph]

Zero core dependencies. The langgraph extra just adds langgraph as an optional dependency for type checking.

GitHub: https://github.com/bmdhodl/agent47

---

Are you running LangGraph agents in production? How do you handle cost visibility and runaway graph executions? Would love to hear your approach.