Aller au contenu

OpenAI a publié en avril 2026 une mise à jour majeure de l'Agents SDK, la plus importante depuis le projet expérimental Swarm. Les nouvelles fonctionnalités incluent l'exécution sandbox native, le framework d'exécution natif au modèle, la prise en charge du protocole MCP, etc. Cet article vous guidera du débutant à la production pour maîtriser les fonctionnalités clés et les techniques pratiques d'OpenAI Agents SDK 2026.

Qu'est-ce qu'OpenAI Agents SDK ?

OpenAI Agents SDK est la bibliothèque Python officielle d'OpenAI pour construire des applications d'Agent IA de niveau production. Elle offre une API simple mais puissante permettant aux développeurs de créer rapidement des agents dotés de capacités d'appel d'outils, de dialogue multi-tours et de protection de sécurité.

L'évolution de Swarm à Agents SDK

En 2024, OpenAI a publié Swarm comme framework expérimental multi-agents. Bien que Swarm ait démontré les possibilités de collaboration entre agents, il manquait de mécanismes de sécurité et de support de persistance nécessaires pour l'environnement de production.

En avril 2026, OpenAI a lancé le nouvel Agents SDK, reconstruit de fond en comble :

  • Exécution Sandbox native : Le code s'exécute dans un environnement isolé, empêchant les opérations malveillantes
  • Harness natif au modèle : Capacités de configuration de la mémoire et de l'orchestration
  • Prise en charge du protocole MCP : Intégration transparente avec l'écosystème d'outils externes
  • Sécurité entreprise : Guardrails intégrés et validation des entrées

Principes de conception fondamentaux

L'Agents SDK suit ces principes de conception :

  1. Simplicité d'abord : Réaliser des fonctionnalités complexes avec le moins de code possible
  2. Sécurité prioritaire : Mécanismes de protection activés par défaut
  3. Extensibilité : Support des outils personnalisés et des middlewares
  4. Prêt pour la production : Traçage, surveillance et gestion des erreurs intégrés

Détails de la mise à jour majeure d'avril 2026

Exécution Sandbox (Sandbox Execution)

L'exécution sandbox est la fonctionnalité la plus importante de l'Agents SDK 2026. Elle permet aux agents de s'exécuter en toute sécurité dans un environnement isolé, sans crainte de risques de sécurité.

Caractéristiques principales :

  • Environnement isolé : Chaque agent s'exécute dans un conteneur indépendant
  • Accès au système de fichiers : Lecture/écriture de fichiers temporaires, support de l'installation de dépendances
  • Contrôle réseau : Configuration des permissions d'accès réseau
  • Limites de ressources : Limites configurables pour CPU, mémoire et temps d'exécution

L'Agents SDK supporte actuellement plusieurs fournisseurs de sandbox :

Architecture Harness native au modèle

Harness est la couche d'orchestration centrale de l'Agents SDK, responsable de la gestion du flux d'exécution de l'agent :

Mémoire configurable (Configurable Memory) :

from agents import Agent, Runner, Memory

# Configuration de la mémoire persistante
memory = Memory(
    type="persistent",
    storage="redis",  # Supporte redis, postgres, sqlite
    ttl=3600  # Temps d'expiration de la mémoire
)

agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant",
    memory=memory
)

Orchestration consciente du sandbox :

Harness peut déterminer intelligemment quand démarrer un environnement sandbox et gérer automatiquement le cycle de vie des ressources.

Support natif du protocole MCP

MCP (Model Context Protocol) est un protocole ouvert d'Anthropic pour standardiser l'interaction entre les modèles d'IA et les outils externes. OpenAI Agents SDK 2026 prend en charge MCP nativement, ce qui signifie que vous pouvez :

  • Utiliser n'importe quel outil compatible MCP
  • Partager l'écosystème d'outils avec Claude Code
  • Construire des applications d'agent portables
from agents import Agent, MCPTools

# Connexion au serveur MCP
mcp_tools = MCPTools.from_server("http://localhost:3000/sse")

agent = Agent(
    name="MCP Agent",
    instructions="Use available tools to help the user",
    tools=mcp_tools.get_tools()
)

Démarrage rapide : Construire votre premier Agent

Installation et configuration de l'environnement

Tout d'abord, assurez-vous d'avoir une clé API OpenAI. Installez ensuite l'Agents SDK :

pip install openai-agents

Configurez les variables d'environnement :

export OPENAI_API_KEY="votre-cle-api-ici"

Exemple Hello World

Créez l'agent le plus simple :

from agents import Agent, Runner

# Création de l'agent
agent = Agent(
    name="Assistant",
    instructions="You are a helpful assistant"
)

# Exécution de l'agent
result = Runner.run_sync(agent, "Write a haiku about recursion.")
print(result.final_output)

Exemple de sortie :

Code calls itself deep,
Infinite mirrors reflect—
Base case breaks the loop.

Ajout d'appels d'outils

Donnez à l'agent des capacités pratiques :

from agents import Agent, Runner, function_tool
from pydantic import BaseModel

# Définition des paramètres de l'outil
class WeatherInput(BaseModel):
    city: str
    unit: str = "celsius"

@function_tool
async def get_weather(input: WeatherInput) -> str:
    """Get weather information for a city."""
    # Ici, vous pouvez appeler une API météo réelle
    return f"The weather in {input.city} is 22°{input.unit[0].upper()}"

# Création de l'agent avec outils
agent = Agent(
    name="Weather Assistant",
    instructions="You help users with weather information.",
    tools=[get_weather]
)

# Exécution
result = Runner.run_sync(agent, "What's the weather like in Tokyo?")
print(result.final_output)

Pratique : Construire un Agent de révision de code avec sandbox

Description du scénario

Nous allons construire un agent capable de réviser du code Python, qui peut :

  1. Exécuter du code dans un environnement sandbox
  2. Vérifier le style du code et les problèmes potentiels
  3. Générer des rapports de révision détaillés

Implémentation complète du code

import asyncio
from agents import Agent, Runner, SandboxAgent, function_tool
from pydantic import BaseModel
from typing import List

class CodeReviewInput(BaseModel):
    code: str
    filename: str = "script.py"

class CodeReviewResult(BaseModel):
    issues: List[str]
    suggestions: List[str]
    execution_output: str
    passed: bool

@function_tool
async def run_code_in_sandbox(input: CodeReviewInput) -> str:
    """Execute Python code in a secure sandbox environment."""
    # Utilisation de SandboxAgent pour exécuter le code
    sandbox = SandboxAgent(
        provider="e2b",  # Utilisation du sandbox E2B
        timeout=30,  # Timeout de 30 secondes
        memory_limit="512mb",
        cpu_limit=1.0
    )

    # Écriture du fichier de code
    await sandbox.write_file(f"/home/user/{input.filename}", input.code)

    # Exécution du code
    result = await sandbox.execute(
        f"python /home/user/{input.filename}",
        env={"PYTHONUNBUFFERED": "1"}
    )

    return result.stdout + result.stderr

@function_tool
async def analyze_code_style(code: str) -> List[str]:
    """Analyze code style using pylint in sandbox."""
    sandbox = SandboxAgent(provider="e2b")

    # Installation de pylint
    await sandbox.execute("pip install pylint -q")

    # Écriture du code
    await sandbox.write_file("/home/user/temp.py", code)

    # Exécution de pylint
    result = await sandbox.execute("pylint /home/user/temp.py --output-format=text")

    issues = []
    for line in result.stdout.split("\n"):
        if ":" in line and any(severity in line for severity in ["E", "W", "C", "R"]):
            issues.append(line.strip())

    return issues

# Création de l'agent de révision de code
code_reviewer = Agent(
    name="Code Reviewer",
    instructions="""You are an expert Python code reviewer. Your task is to:
1. Run the code in a sandbox to check for runtime errors
2. Analyze code style and best practices
3. Provide actionable suggestions for improvement
4. Generate a comprehensive review report

Be thorough but constructive in your feedback.""",
    tools=[run_code_in_sandbox, analyze_code_style],
    model="gpt-4o"  # Utilisation d'un modèle plus puissant pour l'analyse de code
)

async def review_code(user_code: str, filename: str = "script.py"):
    """Review code using the Code Reviewer Agent."""
    prompt = f"""Please review the following Python code:

Filename: {filename}

```python
{user_code}

Please: 1. Run the code and report any execution errors 2. Check code style issues 3. Provide specific suggestions for improvement 4. Give an overall assessment (PASS or FAIL)

Format your response as a structured code review report."""

result = await Runner.run(code_reviewer, prompt)
return result.final_output

Exemple de code à réviser

sample_code = ''' def calculate_sum(numbers): total = 0 for n in numbers: total = total + n return total

result = calculate_sum([1, 2, 3, 4, 5]) print(f"Sum: {result}") '''

Exécution de la révision

if name == "main": review = asyncio.run(review_code(sample_code, "calculate_sum.py")) print(review)


### Exécution et test

En exécutant le code ci-dessus, l'agent va :

1. Exécuter le code dans le sandbox E2B
2. Utiliser pylint pour vérifier le style du code
3. Générer un rapport complet incluant les résultats d'exécution, les problèmes de style et les suggestions d'amélioration

**Exemple de sortie** :

Code Review Report for calculate_sum.py

Execution Results ✅

  • Status: Success
  • Output: Sum: 15
  • Runtime: 0.23s

Style Analysis ⚠️

  • Missing module docstring
  • Function lacks type hints
  • Variable 'total' could use augmented assignment (total += n)

Suggestions for Improvement

  1. Add type hints: def calculate_sum(numbers: List[int]) -> int:
  2. Use built-in sum() function for simplicity
  3. Add docstring explaining the function's purpose
  4. Consider handling empty list edge case

Overall Assessment: PASS with recommendations


## Sécurité et meilleures pratiques

### Configuration des Guardrails

L'Agents SDK fournit une protection multi-couches :

```python
from agents import Agent, Guardrails, InputGuardrail, OutputGuardrail

# Validation des entrées
def validate_input(context) -> bool:
    """Check if input is safe to process."""
    forbidden_patterns = ["rm -rf", "exec(", "eval("]
    return not any(pattern in context.user_input for pattern in forbidden_patterns)

# Filtrage des sorties
def filter_output(response) -> str:
    """Filter sensitive information from output."""
    # Suppression des clés API, mots de passe potentiels
    import re
    response = re.sub(r'sk-[a-zA-Z0-9]{48}', '[API_KEY_REDACTED]', response)
    return response

agent = Agent(
    name="Safe Agent",
    instructions="You are a helpful assistant",
    guardrails=Guardrails(
        input_guardrails=[InputGuardrail(check=validate_input)],
        output_guardrails=[OutputGuardrail(filter=filter_output)]
    )
)

Validation des entrées

Utilisation de Pydantic pour une validation stricte des entrées :

from pydantic import BaseModel, Field, validator

class SafeCodeInput(BaseModel):
    code: str = Field(..., max_length=5000)
    language: str = Field(default="python", regex="^(python|javascript|bash)$")

    @validator('code')
    def check_forbidden_patterns(cls, v):
        forbidden = ['import os', 'import subprocess', '__import__']
        for pattern in forbidden:
            if pattern in v.lower():
                raise ValueError(f"Forbidden pattern detected: {pattern}")
        return v

Gestion des erreurs

La gestion des erreurs est essentielle en environnement de production :

from agents import Agent, Runner
from agents.exceptions import AgentError, ToolError, SandboxError

async def safe_run(agent: Agent, prompt: str):
    try:
        result = await Runner.run(agent, prompt)
        return result.final_output
    except SandboxError as e:
        # Échec de l'exécution sandbox
        return f"Sandbox execution failed: {e.message}"
    except ToolError as e:
        # Échec de l'appel d'outil
        return f"Tool execution error: {e.message}"
    except AgentError as e:
        # Erreur interne de l'agent
        return f"Agent error: {e.message}"
    except Exception as e:
        # Erreur inconnue
        return f"Unexpected error: {str(e)}"

Agents SDK vs autres frameworks

vs LangGraph

Caractéristique Agents SDK LangGraph
Courbe d'apprentissage Faible Élevée
Orchestration multi-agents Intégrée Nécessite configuration
Support sandbox Natif Nécessite intégration
Support MCP Natif Nécessite adaptation
Visualisation Traçage intégré LangSmith
Scénarios d'application Développement rapide Workflows complexes

Recommandation : Choisissez Agents SDK pour les prototypes rapides, LangGraph pour les workflows d'entreprise complexes.

vs CrewAI

CrewAI se concentre sur les scénarios de collaboration multi-agents :

  • Agents SDK : Capacités d'agent unique fortes, l'exécution sandbox est un avantage
  • CrewAI : Plus mature pour le jeu de rôles et la délégation de tâches entre agents

Recommandation : Choisissez CrewAI pour le jeu de rôles et la collaboration entre agents, Agents SDK pour l'exécution sécurisée du code.

vs Claude Code SDK

Le Claude Code d'Anthropic offre également des capacités d'agent :

  • Agents SDK : Intégration profonde avec les modèles OpenAI, écosystème d'outils riche
  • Claude Code : Fonctionne mieux avec Claude 3.5/3.7 Sonnet, forte capacité de compréhension du code

Recommandation : Choisissez Agents SDK avec les modèles OpenAI, Claude Code avec les modèles Claude.

Recommandations de déploiement en production

Persistance et gestion d'état

Les environnements de production nécessitent la persistance de l'état de l'agent :

from agents import Agent, Memory, RedisStorage

# Utilisation de Redis comme stockage d'état
storage = RedisStorage(
    host="localhost",
    port=6379,
    db=0,
    password="votre-mot-de-passe"
)

memory = Memory(
    type="persistent",
    storage=storage,
    ttl=86400  # Expiration après 24 heures
)

agent = Agent(
    name="Stateful Agent",
    instructions="You remember previous conversations",
    memory=memory
)

Surveillance et traçage

L'Agents SDK intègre des fonctionnalités de traçage :

from agents import Agent, Runner, Tracing

# Activation du traçage détaillé
Tracing.configure(
    enabled=True,
    endpoint="https://api.openai.com/v1/traces",
    sample_rate=1.0  # Échantillonnage à 100%
)

# Le traçage automatique de toutes les étapes lors de l'exécution
result = Runner.run_sync(agent, "Hello")

# Affichage des informations de traçage
print(result.trace_id)  # Peut être utilisé pour visualiser les détails sur la plateforme OpenAI

Contrôle des coûts

Les applications d'agent peuvent générer des coûts API élevés, recommandations :

  1. Utiliser le modèle approprié : Tâches simples avec GPT-4o-mini, tâches complexes avec GPT-4o
  2. Définir des limites de tokens :
agent = Agent(
    name="Cost-conscious Agent",
    instructions="Be concise in your responses",
    model_settings={
        "max_tokens": 500,
        "temperature": 0.3  # Réduction de l'aléatoire, diminution de la consommation de tokens
    }
)
  1. Mettre en cache les réponses fréquentes :
from functools import lru_cache

@lru_cache(maxsize=1000)
def cached_agent_run(prompt: str) -> str:
    result = Runner.run_sync(agent, prompt)
    return result.final_output

Résumé et perspectives

Points clés à retenir

OpenAI Agents SDK 2026 apporte des mises à jour révolutionnaires :

  1. Exécution Sandbox : Exécution sécurisée du code, élimination des risques de sécurité
  2. Support MCP : Intégration transparente avec l'écosystème d'outils externes
  3. Architecture Harness : Capacités de configuration de la mémoire et de l'orchestration
  4. Prêt pour la production : Protection de sécurité intégrée et surveillance/traçage

Fonctionnalités à venir

Selon l'annonce officielle d'OpenAI, les fonctionnalités suivantes seront bientôt publiées :

  • Subagents : Support des sous-agents, réalisation de hiérarchies d'agents plus complexes
  • Code Mode : Mode optimisé spécifiquement pour la génération et l'édition de code
  • Support TypeScript : Actuellement uniquement Python, la version TS arrive bientôt

Ressources d'apprentissage recommandées

Articles connexes

OpenAI Agents SDK 2026 est l'un des meilleurs choix pour construire des agents IA de niveau production. Que vous souhaitiez développer rapidement un prototype ou construire une application d'entreprise, il offre les fonctionnalités et la sécurité nécessaires. Commencez dès maintenant votre voyage avec Agents SDK !