Free guide

How OpenAI's Control Room Stops a Model in 35 Seconds (and How to Build the Same Stop for Your Agents)

OpenAI can now stop any model running in its research lab within 35 seconds, without touching the job's code. Here's the mechanism, step by step, and how to put the same kind of stop in front of your own agents.

By Beau Johnson·
The Short this guide goes with: How OpenAI's Control Room Stops a Model in 35 Seconds (and How to Build the Same Stop for Your Agents)

Quick answer

Control Room is a central OpenAI service that every research job has to check with before its model produces more output. Each job gets a job_id, and the inference engine asks Control Room for permission on every request; once a job is marked stopped, its next request is denied. The longest it takes from the stop instruction to no more progress is 35 seconds, because of a caching layer, and if Control Room goes down every request is denied.

The short version

  • Every research job gets a job_id, and the model's inference engine asks Control Room for permission on every request before it produces more output.
  • When a monitor model flags a problem, it tells Control Room to stop that job_id, and the job's next request to any model is refused. Stop to standstill takes at most 35 seconds.
  • The stop lives in the inference layer, not in the job's code, and it fails closed: if Control Room goes down or is tampered with, all requests are denied.

How it actually works

Every job is a numbered train

When a researcher starts a job (a reinforcement learning run, an evaluation, a sampling or data processing job), the job's code asks Control Room for a new job_id. Think of it as the number painted on the front of a train: everything that job does from now on carries that number.

One signal box, asked before every stretch of track

Whenever the job needs more tokens, it sends a request to an inference engine (the model running on GPUs) with its job_id. Before the engine answers, it asks the Control Room service whether that job is still allowed to run. OpenAI says all model inference in its research is subject to that check on every request.

A monitor pulls the lever

OpenAI's frontier reinforcement learning jobs run with a monitor: another model that inspects everything the model being trained is doing and raises an alert if it sees a problem. If the monitoring system decides to stop a job, it sends that job_id to Control Room, which records the job as terminated. The next request from that job, to any model on any engine, is denied, so the output stops.

Why the brake is in the track, not the train

Job code is written by many researchers and changes often, so OpenAI doesn't trust it to carry a critical safety stop. There are only a very small number of inference code paths across OpenAI research, so the check lives there, where every job has to pass. The 35-second worst case comes from a caching layer that lets Control Room handle the traffic, and OpenAI says it is working to drive that toward zero. The system also fails closed: if Control Room goes down, through an error or tampering, all inference requests are denied until it's back.

How to set it up

  1. 1.Give every agent run its own ID

    When your app or script starts an agent run, create an ID for it (a UUID is fine) and store it with a status of running. Pass that ID along with every model call the run makes, the same way OpenAI's jobs carry a job_id.

  2. 2.Put the check in the one function every model call goes through

    Don't trust each agent's own code to stop itself. Route every model call through one shared wrapper and have the wrapper ask your stop list first. This is a minimal sketch of the pattern (our own code, not OpenAI's), with a short cache and a fail-closed default:

    import json, time, urllib.request
    
    STATUS_URL = "https://your-control-service.example/runs/{run_id}"  # your own tiny service
    CACHE_SECONDS = 5
    _cache = {}
    
    class RunStopped(Exception):
        pass
    
    def allowed(run_id):
        hit = _cache.get(run_id)
        if hit and time.time() - hit[1] < CACHE_SECONDS:
            return hit[0]
        try:
            with urllib.request.urlopen(STATUS_URL.format(run_id=run_id), timeout=2) as r:
                ok = json.load(r).get("status") == "running"
        except Exception:
            ok = False  # fail closed: no answer means no more output
        _cache[run_id] = (ok, time.time())
        return ok
    
    def call_model(run_id, send, request):
        if not allowed(run_id):
            raise RunStopped(run_id)
        return send(request)
  3. 3.Wire your alerts to the stop list

    Whatever watches your agents (a monitor model, a cost alarm, a rule that spots a dangerous command, or you) should be able to flip a run's status to stopped by its ID. With the wrapper above, the run's next model call is refused within your cache time.

  4. 4.Test it on purpose

    Start a harmless run, mark it stopped, and time how long it takes to stop producing output. Then turn your status service off and confirm every run is refused instead of carrying on. That second test is the fail-closed part, and it's the one people skip.

The fine print

  • Control Room covers OpenAI's research infrastructure (training, evaluation, sampling and data processing jobs). OpenAI says its external model-serving stack, which runs ChatGPT and the API, is already more centralized and has its own way to take deployments down quickly.
  • 35 seconds is OpenAI's stated maximum from Control Room receiving a stop instruction to further progress being impossible. OpenAI hasn't published more detail on how it was measured.
  • Fail-closed was live on all frontier model research workloads when OpenAI posted on November 9, 2026, and was finishing its rollout to the remaining research workloads over the following days.
  • The code above is our illustration of the same pattern for small agent setups. It is not OpenAI's code, and a cache longer than a few seconds means a stopped run can keep going for that long.

FAQ

What is OpenAI Control Room?

A central OpenAI system that tracks model workloads across its research infrastructure and can stop them when safety or security concerns come up. Every research inference request has to get Control Room's permission first.

How fast can OpenAI stop a model?

OpenAI says Control Room halts model output within 35 seconds of a decision to intervene. The delay comes from a caching layer for the permission checks, and OpenAI says it is working to bring it down to zero.

What happens if Control Room itself goes down?

It fails closed. If the Control Room service goes down, from an error, being disabled or tampering, the inference engines deny all requests until it's running normally again.

Does Control Room apply to ChatGPT and the API?

No. OpenAI built it for its research infrastructure, where the need is greatest. It says its external serving stack for products is already centralized, with its own ability to take model deployments down quickly.

How does Control Room work with misalignment monitoring?

OpenAI's frontier reinforcement learning jobs run with a monitor model that watches what the model being trained does. If the monitoring system decides to stop a job, it sends the job_id to Control Room, and that job's next inference request is denied.

Sources

Facts checked 2026-11-10 against OpenAI's Control Room post (openai.com/index/control-room, Nov 9 2026) and the @OpenAI announcement on X.

Want help building with tools like this?

Join the Shipping Skool community free. Paid members get live bootcamp calls every week and weekly-updated courses.

Join Shipping Skool

More free guides