Cost tracking for LangGraph agents — per-node budget enforcement

[bmdhodl]

LangGraph is great for building multi-step agent workflows, but cost tracking gets tricky when you have multiple nodes each making LLM calls. How do you enforce a budget across the whole graph?

I've been using AgentGuard's LangGraph integration which wraps individual nodes with budget guards:

from agentguard import Tracer, BudgetGuard, JsonlFileSink
from agentguard.integrations.langgraph import guarded_node

tracer = Tracer(
    sink=JsonlFileSink("traces.jsonl"),
    service="research-agent",
)
budget = BudgetGuard(max_cost_usd=5.00, warn_at_pct=0.8)

@guarded_node(tracer=tracer, budget_guard=budget)
def research_node(state):
    # Make LLM calls here — cost is tracked automatically
    result = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [result]}

@guarded_node(tracer=tracer, budget_guard=budget)
def summarize_node(state):
    result = llm.invoke([{"role": "user", "content": "Summarize: " + str(state["messages"])}])
    return {"summary": result.content}

The budget guard is shared across all nodes, so the $5 limit applies to the entire graph run — not per-node. If the research node burns $4, the summarize node only has $1 left before BudgetExceeded fires.

What you get

Each node execution is traced as a span in the JSONL output:

{"service": "research-agent", "name": "research_node", "kind": "span", "duration_ms": 2340, "cost_usd": 0.045}
{"service": "research-agent", "name": "summarize_node", "kind": "span", "duration_ms": 1200, "cost_usd": 0.023}

You can see exactly which node costs what, and the budget guard stops execution if the total exceeds your limit.

Combining with loop detection

LangGraph agents can loop (conditional edges that cycle back). Add a loop guard to catch it:

from agentguard import LoopGuard

@guarded_node(
    tracer=tracer,
    budget_guard=budget,
    loop_guard=LoopGuard(max_repeats=3),
)
def research_node(state):
    ...

Install

pip install agentguard47[langgraph]

Zero dependencies in the core SDK, MIT licensed: https://github.com/bmdhodl/agent47

---

Anyone else building multi-node LangGraph agents and tracking costs? How are you handling budget allocation across nodes — flat limit for the whole graph, or per-node budgets?

[UrRhb]

The per-node cost attribution is really useful for debugging which part of a graph is expensive. We built something similar for the Node.js/TypeScript ecosystem with burn0 -- instead of decorator-based wrapping, it patches the HTTP layer so any LLM call from any node gets tracked automatically without changing your agent code. You get the same kind of per-feature cost breakdown.

For the budget allocation question -- we've seen people use a flat limit for the graph and then look at the per-feature data to understand distribution after the fact. Per-node budgets make sense when you have expensive nodes that should be capped independently (like a research node that might recurse). Curious how you've seen people split it in practice.