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. Layer Purpose Guardrail Detection Classifies control on every run based on your traces. Policy Enforcement (@govern) Hard-blocks or pauses execution before a governed function is executed. 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) Enter fullscreen mode Exit fullscreen mode 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. `python 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: python fail_open=False Assembly Line Step Check Track User Input Input for Open Assistant SDK Tier A Finding Agent Execution Tools + LLM Full Trace + Cost Final Output OpenAI SDK Output Guardrail Triggered Categories --- --- --- Side Effects @govern + Platform Policy Hard Block Before Execution 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