Guardrails and Policy Enforcement for OpenAI Agents - How Traccia Proves Controls Fired

Guardrails for Your OpenAI Agent - But can you prove they were fleeing?

You built your agent using the OpenAI Agents SDK.

• ✅ Input guardrail
• ✅ Output Safety Nets
• ✅ Calls to Tools
• ✅ Multi Agent Handovers

Everything looks fine in development. But there are still two questions that matter in production: Did the guardrails actually run-and which ones fired? Can this agent still act when spend, error rate, or organization policy says it shouldn't?

Prompt text is direction. Production systems require proof and enforcement.

Two Layers. One instrumentation route.

These layers are complementary. Detection tells you what went on. **Governance decides what happens next.

Step 1 - One Time Instrument

from traccia import init
from agents import Agent, Runner, input_guardrail, GuardrailFunctionOutput

init()  # OpenAI Agents SDK tracing starts automatically

@input_guardrail
async def scope_check(ctx, agent, input_data):
    return GuardrailFunctionOutput(
        output_info={"allowed": True},
        tripwire_triggered=False,
    )

agent = Agent(
    name="Assistant",
    instructions="Help the user with their request.",
    input_guardrails=[scope_check],
)
result = await Runner.run(agent, user_message)

No extra wiring. Agent spans, guardrail spans, tool calls, latency, and LLM cost all feed into the same trace.

Step 2 - SDK Guardrails Turn Into Tier A Findings

Traccia auto-captures OpenAI Agents SDK Input & Output Guardrails.** No custom annotations. No hand-wrapping. Each trace consists of:

• guardrail.summary.detected_categories
• guardrail.summary.triggered_categories
• guardrail.findings (structured findings for each guardrail span)

Step 3 - Guardrail Placement

For each trace and per agent you get aggregated:

• ✅ Confidence in Coverage
• ✅ Categories Activated
• ✅ Absent Guardrails

Traccia automatically flags an agent with Input Guardrails but no Output Guardrail. Great for:

• Code Review
• Security Audit
• Responding to Incidents
• Production Monitoring

Step 4 - Enforce Side Effects with @govern

Guardrails fire and stop execution using tripwires. @govern checks if the next action is permitted prior to the function being run.

from traccia import init, govern
from traccia.governance import AgentBlockedError

init(api_key="...", endpoint="https://api.traccia.ai/v2/traces")

@govern(agent_id="my-agent", fail_open=False)
def run_side_effect(payload: dict) -> str:
    return execute_action(payload)

try:
    run_side_effect(payload)
except AgentBlockedError:
    return "Agent blocked by policy."

Any operation that has real-world impact should be wrapped with:

• Sends to Database
• Removes
• External API Calls
• Payments
• Distribution of resources
• Anything that has permanent side effects

For critical actions, you should use: fail_open=False

Assembly Line

The Bottom Line

✅ Build Guardrails using the OpenAI Agents SDK
✅ Show that they really shot with Traccia
✅ Restrict the next allowed action of your agent with @govern

One init(). One trace stream. Transparency in every guardrail. Enforcement prior to every critical action. That’s what production AI systems need.

📖 Read More

• Comprehensive guide: https://traccia.ai/blog/openai-agents-guardrails-policy-enforcement