API Agents

L’API Agents, gérée par OpenAI, donne à votre application accès au harnais Codex.

OpenAI gère les sessions, l’orchestration, le compactage du contexte et la reprise après incident. Votre application fournit les outils et choisit son environnement d’exécution.

Les agents peuvent travailler dans un bac à sable pour y exécuter du code, modifier des fichiers, se connecter à des serveurs MCP et produire des artefacts.

Consultez la référence de l’API pour connaître les points de terminaison, les paramètres de requête et les champs de réponse.

Tarification

L’utilisation du modèle est facturée aux tarifs de l’API correspondant au modèle choisi. Les outils OpenAI sont facturés à leurs tarifs standard et les bacs à sable hébergés par OpenAI aux tarifs standard des conteneurs.

Essayez un exemple

Essayez ces exemples complets :

Créez et exécutez un script qui affiche l’arborescence des répertoires dans un bac à sable hébergé par OpenAI.
Comparez des notes de version à l’aide de sous-agents et réunissez leurs conclusions dans une seule réponse.

Découvrez des applications complètes :

Agent de réponse aux incidents : analysez les alertes et demandez l’approbation des mesures de rétablissement.
Bot Slack : examinez les demandes à l’aide des outils connectés de votre organisation.
Analyste de données : répondez à des questions sur votre entrepôt de données à l’aide de requêtes SQL en lecture seule.
Utilisez l’outil d’analyse des issues GitHub pour reproduire les bugs signalés et partager vos conclusions sur GitHub.
Utilisez l’outil de revue documentaire pour examiner des documents à l’aide de skills qui appliquent vos politiques et d’agents spécialisés.

Concepts clés

L’API Agents repose sur quatre concepts principaux :

Agent : le modèle, les instructions, les outils et les serveurs MCP dont dispose l’agent.
Environnement : l’agent peut disposer d’un bac à sable ou d’un ordinateur pour accéder aux fichiers, charger des skills et exécuter des commandes.
Session : une instance persistante d’un agent qui exécute des tâches et répond aux entrées qu’il reçoit.
Événements et éléments : les entrées envoyées à un agent et les sorties qu’il produit au cours d’une session.

Déroulement d’une session

Suivez le guide de démarrage rapide pour commencer avec un bac à sable hébergé par OpenAI :

Créez une session. Configurez l’agent. OpenAI met son environnement à disposition.
Confiez-lui une tâche. Une fois l’environnement prêt, le message de l’utilisateur lance un tour de travail.
Suivez la progression. Recevez les sorties en continu ou utilisez des webhooks pour savoir quand l’agent a terminé ou a besoin de votre intervention.
Poursuivez le travail ou guidez l’agent. Envoyez une autre tâche dans la même session ou guidez l’agent pendant le tour en cours.

Dans une session hébergée par OpenAI, votre application envoie les entrées et reçoit les événements. OpenAI exécute l’agent, met son bac à sable à disposition et en assure la gestion. Consultez les options d’environnement pour connaître les modalités de configuration et les limites.

Votre application démarre des sessions et reçoit les événements et les sorties de l’API Agents. OpenAI gère et exécute le harnais Codex, met son bac à sable à disposition et en assure la gestion.

Fonctionnalités du harnais géré par OpenAI

Le harnais Codex géré par OpenAI permet de :

Exécuter des commandes et du code dans un bac à sable.
Appliquer les skills et les instructions pertinentes.
Accéder à des données externes à l’aide d’outils ou via MCP.
Guider l’agent pendant qu’il travaille.
Résumer le travail déjà effectué pour gérer la fenêtre de contexte de l’agent.
Diviser le travail en sous-tâches et les déléguer à des sous-agents.
Reprendre une session là où elle s’était arrêtée.

Consultez les prérequis du guide de démarrage rapide pour connaître les autorisations nécessaires à la clé API et savoir comment configurer le SDK. Configurez ces fonctionnalités lors de la création d’une session :

Configurez les fonctionnalités du harnais géré par OpenAI

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41import OpenAI from "openai";

const client = new OpenAI();

const session = await client.beta.agents.sessions.create({
  agent: {
    model: "gpt-6-astra",
    instructions:
      "Use the OpenAI documentation MCP and web search to answer technical questions accurately. Delegate independent research tasks to subagents when useful.",
    tools: [
      { type: "programmatic_tool_calling" },
      {
        type: "mcp",
        server_label: "openai_docs",
        transport: {
          type: "http",
          server_url: "https://developers.openai.com/mcp",
        },
      },
      { type: "web_search" },
    ],
    multi_agent: { enabled: true, max_concurrent_subagents: 4 },
  },
  environment: {
    type: "self_hosted",
    workspace_directory: "/workspace",
    capability_directories: ["/workspace/capabilities/skills"],
  },
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Research how to connect an MCP server to an OpenAI agent, check for recent updates, and summarize the recommended setup.",
        },
      ],
    },
  ],
});
console.log(session.id);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40from openai import OpenAI

client = OpenAI()

session = client.beta.agents.sessions.create(
    agent={
        "model": "gpt-6-astra",
        "instructions": "Use the OpenAI documentation MCP and web search to answer technical questions accurately. Delegate independent research tasks to subagents when useful.",
        "tools": [
            {"type": "programmatic_tool_calling"},
            {
                "type": "mcp",
                "server_label": "openai_docs",
                "transport": {
                    "type": "http",
                    "server_url": "https://developers.openai.com/mcp",
                },
            },
            {"type": "web_search"},
        ],
        "multi_agent": {"enabled": True, "max_concurrent_subagents": 4},
    },
    environment={
        "type": "self_hosted",
        "workspace_directory": "/workspace",
        "capability_directories": ["/workspace/capabilities/skills"],
    },
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_text",
                    "text": "Research how to connect an MCP server to an OpenAI agent, check for recent updates, and summarize the recommended setup.",
                }
            ],
        }
    ],
)
print(session.id)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import (
	"context"
	"fmt"
	"github.com/openai/openai-go/v3"
)

ctx := context.Background()
client := openai.NewClient()
session, err := client.Beta.Agents.Sessions.New(ctx, openai.BetaAgentSessionNewParams{Agent: openai.BetaAgentSessionNewParamsAgent{Model: openai.String("gpt-6-astra"),
	Instructions: openai.String("Use the OpenAI documentation MCP and web search to answer technical questions accurately. Delegate independent research tasks to subagents when useful."),
	Tools: []openai.AgentToolParamUnion{openai.AgentToolParamUnion{OfParamProgrammaticToolCalling: &openai.AgentToolParamProgrammaticToolCalling{}},
		openai.AgentToolParamUnion{OfParamMcp: &openai.AgentToolParamMcp{ServerLabel: "openai_docs",
			Transport: openai.McpTransportParamUnion{OfParamHTTP: &openai.McpTransportParamHTTP{ServerURL: "https://developers.openai.com/mcp"}}}},
		openai.AgentToolParamUnion{OfParamWebSearch: &openai.AgentToolParamWebSearch{}}},
	MultiAgent: openai.MultiAgentConfigParam{Enabled: true,
		MaxConcurrentSubagents: openai.Int(4)}},
	Environment: openai.EnvironmentParamUnion{OfParamSelfHosted: &openai.EnvironmentParamSelfHosted{WorkspaceDirectory: "/workspace",
		CapabilityDirectories: []string{"/workspace/capabilities/skills"}}},
	Input: openai.BetaAgentSessionNewParamsInputUnion{OfArrayOfInputMessages: []openai.AgentSessionInputMessageParam{openai.AgentSessionInputMessageParam{Content: []openai.InputContentParamUnion{openai.InputContentParamUnion{OfParamInputText: &openai.InputContentParamInputText{Text: "Research how to connect an MCP server to an OpenAI agent, check for recent updates, and summarize the recommended setup."}}}}}}})
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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.beta.agents.AgentToolParam;
import com.openai.models.beta.agents.EnvironmentParam;
import com.openai.models.beta.agents.McpTransportParam;
import com.openai.models.beta.agents.MultiAgentConfigParam;
import com.openai.models.beta.agents.sessions.SessionCreateParams;
import java.util.List;

OpenAIClient client = OpenAIOkHttpClient.fromEnv();
var session =
    client
        .beta()
        .agents()
        .sessions()
        .create(
            SessionCreateParams.builder()
                .agent(
                    SessionCreateParams.Agent.builder()
                        .model("gpt-6-astra")
                        .instructions(
                            "Use the OpenAI documentation MCP and web search to answer"
                                + " technical questions accurately. Delegate independent"
                                + " research tasks to subagents when useful.")
                        .addTool(AgentToolParam.ProgrammaticToolCalling.builder().build())
                        .addTool(
                            AgentToolParam.Mcp.builder()
                                .serverLabel("openai_docs")
                                .transport(
                                    McpTransportParam.Http.builder()
                                        .serverUrl("https://developers.openai.com/mcp")
                                        .build())
                                .build())
                        .addTool(AgentToolParam.WebSearch.builder().build())
                        .multiAgent(
                            MultiAgentConfigParam.builder()
                                .enabled(true)
                                .maxConcurrentSubagents(4L)
                                .build())
                        .build())
                .environment(
                    EnvironmentParam.SelfHosted.builder()
                        .workspaceDirectory("/workspace")
                        .capabilityDirectories(List.of("/workspace/capabilities/skills"))
                        .build())
                .input(
                    "Research how to connect an MCP server to an OpenAI agent, check for recent"
                        + " updates, and summarize the recommended setup.")
                .build());
System.out.println(session.id());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43require "openai"

client = OpenAI::Client.new

session = client.beta.agents.sessions.create(
  agent: {
    model: "gpt-6-astra",
    instructions: "Use the OpenAI documentation MCP and web search to answer technical questions accurately. Delegate independent research tasks to subagents when useful.",
    tools: [
      { type: "programmatic_tool_calling" },
      {
        type: "mcp",
        server_label: "openai_docs",
        transport: {
          type: "http",
          server_url: "https://developers.openai.com/mcp"
        }
      },
      { type: "web_search" }
    ],
    multi_agent: {
      enabled: true,
      max_concurrent_subagents: 4
    }
  },
  environment: {
    type: "self_hosted",
    workspace_directory: "/workspace",
    capability_directories: ["/workspace/capabilities/skills"]
  },
  input: [
    {
      role: "user",
      content: [
        {
          type: "input_text",
          text: "Research how to connect an MCP server to an OpenAI agent, check for recent updates, and summarize the recommended setup."
        }
      ]
    }
  ]
)
puts session.id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46curl -sS -X POST "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": {
      "model": "gpt-6-astra",
      "instructions": "Use the OpenAI documentation MCP and web search to answer technical questions accurately. Delegate independent research tasks to subagents when useful.",
      "tools": [
        {
          "type": "programmatic_tool_calling"
        },
        {
          "type": "mcp",
          "server_label": "openai_docs",
          "transport": {
            "type": "http",
            "server_url": "https://developers.openai.com/mcp"
          }
        },
        {
          "type": "web_search"
        }
      ],
      "multi_agent": {
        "enabled": true,
        "max_concurrent_subagents": 4
      }
    },
    "environment": {
      "type": "self_hosted",
      "workspace_directory": "/workspace",
      "capability_directories": ["/workspace/capabilities/skills"]
    },
    "input": [
      {
        "role": "user",
        "content": [
          {
            "type": "input_text",
            "text": "Research how to connect an MCP server to an OpenAI agent, check for recent updates, and summarize the recommended setup."
          }
        ]
      }
    ]
  }'

Pour comparer les environnements d’exécution, consultez la présentation des agents.

Pour découvrir le service AWS qui s’appuie sur l’API Agents, consultez la page Bedrock Managed Agents.

L’API Agents conserve l’état de la session pour que vous puissiez poursuivre votre travail d’un tour à l’autre sans reconstituer le contexte de la conversation. Vous pouvez supprimer les sessions et les artefacts publiés lorsque vous n’en avez plus besoin. L’API Agents prend actuellement en charge la résidence des données uniquement aux États-Unis et ne prend pas en charge la politique de non-conservation des données (ZDR). Même si vous hébergez vous-même le bac à sable, l’API Agents reste inéligible à cette politique. Consultez la page Contrôles des données sur la plateforme OpenAI pour en savoir plus sur la résidence et la conservation des données.

Suggestions

Premiers pas

Notions fondamentales

SDK et CLI

Fournisseurs de services cloud

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Rédaction de prompts

Raisonnement

Images

Temps réel et audio

Modèles spécialisés

Agents SDK

ChatKit

Recherche et récupération d’informations

Connectez des outils et des sources de données

Créez des workflows qui font appel à des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Créer des applications vocales

Connexions

Traitement audio

Mise en production

Performances et qualité

Évaluation

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts clés

Planification

Développement

Tests et publication

Spécifications de conversion

Guides

Ressources

Identité

Utilisation du forfait ChatGPT

Guides

Envoi de fichiers

API

Mesure des performances

API pour les annonceurs

Référence de l’API

Premiers pas

Premiers pas

Notions de base

Explorer

Disponible sur

Versions

Workflows

Capacités

Sites

dots

Espace ChatGPT

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendre les fonctionnalités de ChatGPT et de Codex

Linux

Windows

Workflows de développement

Extensions et automatisation

Environnements

Codex Cloud

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Premiers pas

Configuration des fonctionnalités

Identité et accès