Langfuse vs RunGuard

The callback-vs-gate distinction

Langfuse's SDK instruments your LLM calls by inserting callbacks — functions that fire after each API response returns, sending the result to Langfuse's backend for logging. Because callbacks fire post-call, they are structurally incapable of halting the next invocation. An exception raised inside a Langfuse callback is caught by Langfuse's own error handler, not propagated to your agent. The tracer sees everything; it prevents nothing.

RunGuard wraps the call itself. When you write guard(fn), RunGuard replaces fn with a wrapper that runs synchronously before forwarding to fn. If the loop detector fires, the wrapper throws LoopDetectedError and fn is never called — the HTTP request never goes out. This is the gate model vs. the observer model.

Composing Langfuse and RunGuard

The recommended pattern for teams that want both: wrap your LLM function with RunGuard's guard, then wrap the guarded function with Langfuse's tracing. RunGuard decides whether the call should proceed. Langfuse records every call that RunGuard allows through — plus the LoopDetectedError events themselves, which become valuable dataset rows for evaluating your agent's failure modes.

// TypeScript
import { guard } from "@runguard/sdk"
import { observe } from "langfuse"

const fn = async (msg: string) => anthropic.messages.create({ ... })

const traced = observe(fn)           // Langfuse traces what executes
const safe   = guard(traced, {        // RunGuard gates what should execute
  repeats: 3,
  maxUsd: 5,
  windowMs: 60_000
})