The OpenAI Agents SDK gives you agents, tools, handoffs, and guardrails as first-class primitives — including input/output guardrails that can validate what goes into and comes out of a model call. What it doesn't give you is a way to cap what an agent is financially allowed to do, or a tamper-evident record of what it actually did once a handoff chain gets going. That's a different kind of guardrail than the SDK's own input/output validation, and it's the one Valta adds.
Why this is a distinct gap from the SDK's built-in guardrails
The SDK's guardrails are about content — is this input safe to act on, is this output acceptable to return. They run per-call, checking the quality of what's flowing through the agent. They don't address a separate question: regardless of whether every individual call is well-formed and safe, is there a hard ceiling on how many of those calls the agent can make, or what they're collectively allowed to cost? An agent can pass every content guardrail on every single call and still run in an expensive loop, because content safety and spend safety are orthogonal problems. (See what an AI agent spend limit actually requires for what "enforced" means here versus a prompt instruction.)
Handoffs compound this. When one agent hands off to another, and that agent hands off again, a spend ceiling that only exists as an instruction to the first agent has no way to propagate — the second agent in the chain has no inherent awareness of what's already been spent or what the original budget was meant to be.
What Valta adds
A pre-call spend gate in front of every paid action, evaluated before the call executes, not after — regardless of which agent in a handoff chain is making the request.
An instant, per-agent kill switch. Freezing a specific agent (freeze_agent) is enforced at the gateway your agent's calls pass through, not inside the SDK's own process, so it takes effect on the very next action attempt.
A hash-chained audit trail across handoffs. Every request, approval, and denial — across every agent in a handoff chain — is written to one tamper-evident ledger, so a multi-agent handoff produces a single provable record instead of fragments split across each agent's own logging.
How it fits into an Agents SDK setup
Valta sits in front of the tools and external calls your agents make, the same way for the OpenAI Agents SDK as for any other framework — you don't need to restructure how agents, tools, or handoffs are defined. Each agent identity maps to a wallet and spend policy in Valta, so the ceiling travels with the agent, including across a handoff, rather than resetting or disappearing when control passes to a different agent in the chain.
Check what you're running today
valta-leak is a standalone, open-source static analysis CLI you can run against your existing Agents SDK codebase to check for the underlying patterns that cause runaway cost — unbounded loops, missing retry backoff, prompts re-declared inside a loop body — and get a real dollar-per-hour exposure estimate from actual model pricing. It's local-only, makes no network calls, and works as a CI gate (npx valta-leak ./src).
Getting started
The core spend-gate and audit-chain logic is open source and MIT licensed: valta-audit-chain on GitHub.