The OpenAI Agents SDK includes built-in guardrails and human review, and they're worth using. This guide explains what OpenAI Agents SDK guardrails cover, how approvals work, and where teams typically add a centralised policy layer as they scale to many agents and tools. The SDK changes quickly — check OpenAI's current documentation for exact APIs.

Guardrails in the OpenAI Agents SDK

OpenAI's documentation distinguishes two ideas: guardrails decide automatically whether a run continues, while human review pauses a run and asks a person.

Input and output guardrails

Input guardrails check what goes into an agent — for example, blocking off-topic or abusive requests. Output guardrails check the agent's final answer before it's returned. When a guardrail detects a problem, it trips a tripwire, and the SDK raises an exception so the run stops.

Tool guardrails

Tool guardrails run around tool calls. An input tool guardrail runs before a tool executes and can skip the call, replace its output, or trip a tripwire. An output tool guardrail runs after execution and can replace the output or trip a tripwire.

Approvals for sensitive tools

Tools can be marked as needing approval. When the agent wants to call one, the run pauses and returns an interruption; your application asks a person, then approves or rejects and resumes the run.

What OpenAI Agents SDK guardrails do well

  • They live close to the agent, in the same code.
  • Tripwires stop a run immediately.
  • Tool-level checks see the actual call and its arguments.
  • Approvals are built in, with run state preserved while waiting.

Where teams add a policy layer

As the number of agents grows, teams often hit the same issues:

  • Rules scattered in code. Each agent's guardrails define their own thresholds; changing a limit means a deploy, and no one can review all rules in one place.
  • Owners can't read the rules. Finance can't sign off a limit written in Python.
  • Approval routing is up to you. The SDK pauses the run; who gets asked, how fast, and what happens on silence is application logic you build. See AI agent approval workflow.
  • Consistency across frameworks. Agents built with other frameworks — such as LangGraph — need the same rules.
  • Audit. Traces help debugging; reviewers need decision records with rule versions and approvers — see AI agent observability.

A common pattern is to keep SDK guardrails for content and run-level checks, and have a tool guardrail (or the tool wrapper) call a central policy service for action decisions: allow, deny, or require approval — which then triggers the SDK's approval flow. That's the essence of AI agent guardrails enforced outside the model.

Where Gaten fits

Gaten can be that central policy check: one place for readable, versioned rules across every agent and framework, with routed approvals and a decision log. Talk to us about how it fits your OpenAI Agents SDK setup. See how it works.

Frequently asked questions

What guardrails does the OpenAI Agents SDK provide?

Input and output guardrails for runs, tool guardrails around tool calls, tripwires that stop a run, and approval interruptions for tools that need human review.

What is a tripwire in the OpenAI Agents SDK?

A signal from a guardrail that something is wrong. When it trips, the SDK raises an exception and the run stops.

Do I still need a separate policy layer?

Not for a single simple agent. As agents, tools and teams multiply, a central layer helps keep rules readable, consistent, reviewable and auditable.