- Secure MCP Tunnels: Private MCP servers can now connect to ChatGPT, Codex, and the Responses API via outbound-only HTTPS — no inbound firewall rules needed. Docs
- Workload Identity Federation: Replaces permanent API keys with short-lived tokens exchanged via OIDC from AWS, Azure, GCP, Kubernetes, or GitHub Actions. Docs
- Expanded Admin API: New programmatic controls for spend alerts, model allowlists, data retention, and granular cost tracking per project. Docs
- All three features are live on the OpenAI Platform now, targeting enterprise teams running OpenAI at scale.
- tunnel-client is open source on GitHub and supports Kubernetes sidecars, VMs, and dedicated deployments with mTLS and proxy support.
- No model releases involved — this is a pure infrastructure and governance push that removes the main security blockers for enterprise AI adoption.
OpenAI just shipped three infrastructure upgrades that, taken together, represent the most significant enterprise governance push the platform has seen. None of them are model releases. All of them matter if you're running OpenAI at scale inside a real organization.
The package: Secure MCP Tunnels for private-network tool servers, Workload Identity Federation for keyless authentication, and an expanded Admin API with spend alerts, model allowlists, and data retention controls. All three are live on the OpenAI Platform now.
The wall that was blocking enterprise MCP
MCP (Model Context Protocol) is the open standard that lets AI agents call external tools and data sources. The problem for enterprises has never been the protocol itself. The adoption blocker for remote MCP in enterprises has not been protocol support , it has been network policy. Security teams often reject opening inbound firewall rules to internal tool servers, even when OAuth and mTLS are available, because public reachability still expands the attack surface and operational burden.
Secure MCP Tunnel lets you connect private MCP servers to supported OpenAI products without opening inbound firewall ports or exposing those servers to the public internet. You run tunnel-client inside the network that can already reach your MCP server; it opens an outbound HTTPS path to OpenAI, pulls queued MCP work, forwards requests locally, and returns responses through the same tunnel.
How the tunnel actually works
An MCP tunnel is an outbound-only connection from a host inside your network to an OpenAI-hosted MCP endpoint. Use it when your MCP server is private, on-premises, or behind a firewall, but ChatGPT, Codex, the Responses API, or another supported OpenAI surface still needs to call it.
The flow has five steps:
- Create a tunnel endpoint in Platform tunnel settings and get a
tunnel_id - Run
tunnel-clientinside the network that can reach your private MCP server -
OpenAI products send MCP requests to the OpenAI-hosted tunnel endpoint;
tunnel-clientlong-polls for queued work, forwards each JSON-RPC request to the private MCP server, and posts the response back through the tunnel - The private MCP server does not need a public listener , the OpenAI-hosted endpoint gives supported products a normal MCP request path, while the network initiation point stays inside your boundary
- Connect the tunnel from ChatGPT connector settings or any supported OpenAI surface
The minimal setup looks like this:
export CONTROL_PLANE_API_KEY="sk-..."
tunnel-client init \
--sample sample_mcp_stdio_local \
--profile local-stdio \
--tunnel-id tunnel_0123456789abcdef0123456789abcdef \
--mcp-command "python /path/to/server.py"
tunnel-client doctor --profile local-stdio --explain
tunnel-client run --profile local-stdio
tunnel-client supports enterprise networking requirements such as outbound proxies, custom CA bundles, control-plane client certificates, and MCP-side mTLS.
For Kubernetes deployments, the recommended pattern is a sidecar container in the same Pod, connecting over localhost.
There's also a bonus feature baked in:
Secure MCP Tunnel can support narrowly scoped HTTP callouts from supported agent or API flows into a customer network. tunnel-client includes an embedded MCP server called Harpoon that exposes configured HTTP targets by label and lets callers invoke them through the tunnel with bounded request/response limits , useful when you need to reach a small set of private REST endpoints without exposing them publicly.
No more API keys scattered across services
The second feature tackles a problem that predates AI entirely: long-lived API keys are a security liability. Long-lived API keys are the single biggest credential risk in AI infrastructure. Most teams today store OpenAI API keys as environment variables or secrets manager entries, rotate them manually, and share them across services.
Workload identity federation lets trusted workloads exchange externally issued identity tokens for short-lived OpenAI access tokens. The mechanism is OIDC (OpenID Connect) , the same standard used by AWS IAM, Google Cloud, Azure, Kubernetes, and GitHub Actions. Your workload already has a cloud identity; now it can use that identity to get a short-lived OpenAI token instead of holding a permanent key.
It supports IAM workflows from providers like AWS, Azure, Google Cloud, and Kubernetes. This reduces security risks by allowing services to exchange short-lived tokens for access rather than distributing long-term credentials across different environments.
The short-lived tokens expire automatically , there is nothing to rotate, nothing to leak in a git commit, and nothing to revoke after a breach. For teams running coding agents in CI, this is particularly relevant. These agents make large numbers of API calls and often run in environments where secret management is operationally complex. An OIDC-based flow ties the API access to the workload's existing cloud identity rather than a separate credential.
The setup involves four components:
- Workload Identity Provider , describes the trusted issuer (OIDC issuer URL, audience, key source)
- Service account mapping , authorizes specific token attributes to mint tokens for a given OpenAI service account
- Token exchange , the workload sends its external token to OpenAI and receives a short-lived bearer token
- API call , the workload uses the short-lived token like any other bearer credential
One practical tradeoff worth knowing: the token exchange adds a round-trip latency cost and requires the gateway to have an OIDC identity , which is straightforward on AWS/GCP/Azure but requires setup.
Programmatic control over the whole org
The third piece is an expanded Admin API. Admin APIs let you automate organization management workflows such as user invitations, audit log review, project administration, API key management, and rate limit operations.
The new additions are squarely aimed at enterprise governance:
- Spend alerts , get notified before a project blows its budget
- Model allowlists , restrict which models each project can call, enforced at the API level
- Data retention controls , manage how long data is kept per project
- Hosted tool controls , govern access to built-in tools like file search and web search
- Granular cost visibility , separate billing line items for capabilities like file search and web search
Model allowlists interact with routing policy. If you route requests across multiple OpenAI projects , for example, one project per team or per cost center , model allowlists let you enforce different model policies per project at the API level. That's a meaningful shift from relying on application-layer enforcement to having it backed by the API itself.
The Admin API is available across all major SDKs. In Python, initialization looks like:
import os
from openai import OpenAI
client = OpenAI(
admin_api_key=os.environ["OPENAI_ADMIN_KEY"],
)
# Retrieve last 10 audit log entries
audit_logs = client.admin.organization.audit_logs.list(limit=10)What this actually unlocks
These features are live on the OpenAI Platform. Together they change how operators authenticate workloads, enforce model policies, track spend, and reconcile billing , without touching long-lived API keys.
The practical use cases that were previously painful or impossible:
- A CI/CD pipeline running Codex agents that authenticates via GitHub Actions OIDC , no stored API key anywhere in the pipeline
- An internal knowledge-base MCP server sitting behind a corporate firewall, now reachable by ChatGPT connectors without any firewall rule changes
- An enterprise platform team enforcing that the finance project can only call
gpt-4.1while the research project gets access to newer models , enforced at the API level, not just in code - Automated spend alerts that fire before a runaway agent job burns through a project's monthly budget
Pricing for the tunnel feature is not yet publicly documented. The Workload Identity Federation and Admin API features are included in the existing platform access , you need to be an organization owner to configure the identity federation provider.
The tunnel-client binary is open source and available on GitHub. The workload identity federation guide covers setup for Kubernetes, AWS, Azure, Google Cloud, and GitHub Actions individually.