Automatic review

Automatic review approves or denies supported approval requests as an agent works, much like the automatic approval function in ChatGPT and Codex. Configure it using the review field when you create a session for your agent. The setting applies to root turns and any subagents they create.

How it works

Automatic review brings the “Approve for me” functionality of the Codex harness to your agents. During a session, approval requests can arise when an agent’s intended action requests additional permissions. Some example actions that could raise approval requests:

• Shell commands and terminal input that require approval, such as permission escalation or potentially dangerous commands.
• File changes that require approval.
• Additional permission requests, such as broader filesystem or network access.
• Network access requests that trigger approval, subject to the environment’s network restrictions.
• MCP tool calls whose approval rules require confirmation.

An OpenAI-managed reviewer model uses the conversation context to assess what the action would do, what risks it poses, and whether the action aligns with the user’s intent. The model then approves or denies the request.

Tokens used for review are billed in addition to your agent’s model usage.

Your application still handles browser origin-access and sign-in requests. MCP forms that require input and requests that direct the user to a URL follow their existing flows. Automatic review does not require new approval event handlers. See Events and items to follow the agent’s progress and check the turn’s outcome.

Choose a review mode

Set the session’s review field to choose the behavior:

Omitting review defaults to "none". The setting persists when the session resumes. To change it, send "auto_review" or "none"; null is not accepted. Setting review to "none" does not send those actions to your application for manual approval.

Prepare the execution environment

For OpenAI-hosted execution, create the session with a new environment, optionally from an environment template. Automatic review is not supported when reusing an existing hosted environment through environment_id.

For self-hosted execution, follow the self-hosted environment setup and the sandbox prerequisites for your operating system before enabling automatic review. Setting review alone does not configure sandboxing in your environment.

Automatic review does not change the environment’s network restrictions. Configure outbound access through the environment’s network settings. Browser origin approval does not override those restrictions.

Create a session with automatic review

Set review to "auto_review" when you create a session. This example asks the agent to run npm install in /workspace.

With your API key and SDK configured, use an existing agent and an environment template that provides Node.js and a project containing /workspace/package.json. Replace the example agent and template IDs with your own.

1
2
3
4
5
6
7
8
9
10
11
12
13import OpenAI from "openai";

const client = new OpenAI();
const session = await client.beta.agents.sessions.create({
  agent_id: "agt_123",
  environment: {
    type: "openai_hosted",
    environment_template_id: "envtmpl_123",
  },
  review: "auto_review",
  input: "Run npm install in /workspace.",
});
console.log(session.id);

1
2
3
4
5
6
7
8
9
10
11
12
13from openai import OpenAI

client = OpenAI()
session = client.beta.agents.sessions.create(
    agent_id="agt_123",
    environment={
        "type": "openai_hosted",
        "environment_template_id": "envtmpl_123",
    },
    review="auto_review",
    input="Run npm install in /workspace.",
)
print(session.id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

client := openai.NewClient()
session, err := client.Beta.Agents.Sessions.New(context.Background(), openai.BetaAgentSessionNewParams{
	AgentID: openai.String("agt_123"),
	Environment: openai.EnvironmentParamUnion{
		OfParamOpenAIHosted: &openai.EnvironmentParamOpenAIHosted{
			EnvironmentTemplateID: openai.String("envtmpl_123"),
		},
	},
	Review: openai.BetaAgentSessionNewParamsReviewAutoReview,
	Input:  openai.BetaAgentSessionNewParamsInputUnion{OfString: openai.String("Run npm install in /workspace.")},
})
if err != nil {
	panic(err)
}
fmt.Println(session.ID)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.beta.agents.EnvironmentParam;
import com.openai.models.beta.agents.sessions.SessionCreateParams;

OpenAIClient client = OpenAIOkHttpClient.fromEnv();
var session =
    client
        .beta()
        .agents()
        .sessions()
        .create(
            SessionCreateParams.builder()
                .agentId("agt_123")
                .environment(
                    EnvironmentParam.OpenAIHosted.builder()
                        .environmentTemplateId("envtmpl_123")
                        .build())
                .review(SessionCreateParams.Review.AUTO_REVIEW)
                .input("Run npm install in /workspace.")
                .build());
System.out.println(session.id());

1
2
3
4
5
6
7
8
9
10
11
12
13require "openai"

client = OpenAI::Client.new
session = client.beta.agents.sessions.create(
  agent_id: "agt_123",
  environment: {
    type: :openai_hosted,
    environment_template_id: "envtmpl_123"
  },
  review: :auto_review,
  input: "Run npm install in /workspace."
)
puts session.id

1
2
3
4
5
6
7
8
9
10
11
12
13curl --fail-with-body https://api.openai.com/v1/agents/sessions \
  -H "OpenAI-Beta: agents=v1" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "agt_123",
    "environment": {
      "type": "openai_hosted",
      "environment_template_id": "envtmpl_123"
    },
    "review": "auto_review",
    "input": "Run npm install in /workspace."
  }'

Use the returned session id to change the review mode between tasks. See the Create session reference for the request fields.

Your project must have access to automatic review. If it is unavailable, the API rejects requests to enable it and identifies review as the affected parameter.

Change the review mode

Update the session’s review field between tasks. The main task must be idle and input submission must have settled before you change the mode. This example turns off automatic review. Replace sess_123 with the session ID returned above:

const updatedSession = await client.beta.agents.sessions.update("sess_123", {
  review: "none",
});
console.log(updatedSession.id);

updated_session = client.beta.agents.sessions.update("sess_123", review="none")
print(updated_session.id)

updatedSession, err := client.Beta.Agents.Sessions.Update(context.Background(), "sess_123", openai.BetaAgentSessionUpdateParams{
	Review: openai.BetaAgentSessionUpdateParamsReviewNone,
})
if err != nil {
	panic(err)
}
fmt.Println(updatedSession.ID)

import com.openai.models.beta.agents.sessions.SessionUpdateParams;

var updatedSession =
    client
        .beta()
        .agents()
        .sessions()
        .update(
            SessionUpdateParams.builder()
                .sessionId("sess_123")
                .review(SessionUpdateParams.Review.NONE)
                .build());
System.out.println(updatedSession.id());

updated_session = client.beta.agents.sessions.update("sess_123", review: :none)
puts updated_session.id

curl --fail-with-body https://api.openai.com/v1/agents/sessions/sess_123 \
  -X POST \
  -H "OpenAI-Beta: agents=v1" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "review": "none"
  }'

The update returns 200 OK and the updated session. Omit review from other session updates to leave it unchanged. To enable automatic review again, send "review": "auto_review". See the Update session reference for the request fields.

A request to change the mode while the main task is active or input submission has not settled returns 409 Conflict. None of the updates in that request are applied. Retry after the task is idle and input submission has settled. Handle 409 even after checking the session’s status, because new input can arrive before the update. Sending the current review value is allowed while work is active.

Retrieve or list sessions to inspect the saved review value. If the response omits the field, treat it as "none".