Skip to content
Agentic Control Plane

Govern the OpenAI Agents SDK

The OpenAI Agents SDK is OpenAI’s framework for multi-agent systems with tools, handoffs, and guardrails. Its handoff primitive maps directly onto ACP’s delegation chain — every agent transition becomes a chain link with proper scope intersection and budget propagation.

Disambiguation

The OpenAI Agents SDK is distinct from:

  • Codex CLI — terminal application, governed via hooks
  • Assistants API — older thread-based; tools execute server-side at OpenAI, hard to instrument
  • AgentKit — newer visual builder + hosted runtime, partial coverage

For SDK code running in your infrastructure with the agents library, this is the right page.

TL;DR — adapter pattern (works today)

from agents import Agent, Runner
from acp_governance_openai_agents import govern  # pre-release

governed_researcher = govern(
    Agent(
        name="researcher",
        instructions="...",
        tools=[web_search, hn_search],
    ),
    agent_name="researcher",
)

governed_writer = govern(
    Agent(
        name="writer",
        instructions="...",
        tools=[],
        handoffs=[],
    ),
    agent_name="writer",
)

result = await Runner.run(governed_researcher, "Research X and hand off to writer")

Each agent becomes a distinct entity in ACP. Handoffs register as delegation chain links automatically.

How it works

The adapter wraps each Agent with three behaviors:

  1. Pre-tool gate — every tool call POSTs to ACP’s /govern/tool-use for policy evaluation
  2. Handoff capture — when an agent hands off to another, the adapter starts a new chain link (parentAgent, narrowed scopes, propagated budget)
  3. Guardrail layering — your SDK guardrails run first, then ACP policy. Most-restrictive wins.

The OAI proxy path (base_url=api.agenticcontrolplane.com/v1) governs LLM calls but not the SDK’s handoff semantics directly.

Mapping to ACP

OpenAI Agents SDK ACP
Agent(name=...) agent_name field, optionally a registered AgentProfile
Agent.tools Per-agent tool allowlist (intersected with chain)
handoffs Delegation chain links
Runner.run() Root of the chain (originSub = the human)
Guardrails Layered with ACP policy — both must pass

What you’ll see in the dashboard

cloud.agenticcontrolplane.com/agents shows each agent as a distinct row. Handoff sequences render as delegation chains in Run Details — researcher → writer with budget remaining and scope set per hop.

Limitations

  • Adapter pre-release. Functional, not yet on PyPI.
  • Tracing integration is parallel, not unified. Your OpenAI traces still go to the OpenAI dashboard; ACP audit logs are independent. Both serve different audiences.
  • Guardrails are SDK-internal. They run before ACP. ACP has no visibility into guardrail decisions — only the final tool call.
  • Async by design — the adapter is async-first; sync wrappers exist but add small overhead.
  • Handoff chains can grow large. Bound them with ACP’s maxDelegationDepth plan limit.