OpenAI Agents SDK : comment créer un système multi-agent pour Gmail et Slack

Les systèmes IA multi-agents représentent l’une des avancées les plus marquantes dans les applications IA concrètes aujourd’hui.

Contrairement aux approches classiques à agent unique, les systèmes multi-agents répartissent les tâches complexes entre des agents spécialisés, chacun prenant en charge ce qu’il fait le mieux.

Dans cet article, nous explorons un exemple concret qui utilise des agents spécialisés avec accès aux outils Gmail et Slack. Cela implique l’intégration de deux frameworks. L’OpenAI Agents SDK exécute et orchestre les agents, et Arcade.dev gère les outils et l’authentification nécessaires à leur utilisation.

Vous comprendrez les concepts fondamentaux des handoffs entre agents, des contrôles human-in-the-loop, et les bases techniques nécessaires pour créer vos propres applications multi-agents.

Comprendre l’architecture multi-agent

Un système multi-agent est composé d’agents IA spécialisés, conçus pour traiter des tâches précises tout en collaborant via un framework de communication structuré.
Cette architecture présente plusieurs avantages par rapport aux approches à agent unique :

• Séparation des responsabilités : Un agent unique sera probablement correct sur la plupart des sujets, mais pas excellent dans un domaine particulier. En découpant les tâches en périmètres plus étroits, on peut confier chaque tâche à un agent expert, ce qui améliore la précision et la performance.
• Optimisation des coûts : Les derniers LLMs sont impressionnants par leurs capacités de raisonnement, mais aussi très coûteux à faire tourner. Un système multi-agent permet d’associer chaque tâche à un agent utilisant des modèles plus légers, adaptés à leur périmètre.
• Composabilité et adaptabilité : Les systèmes multi-agents s’adaptent facilement aux situations changeantes. Ajouter ou retirer des agents est simple et ne nécessite ni ré-entraînement ni ré-optimisation d’un agent unique.
• Traitement parallèle : Un agent unique travaille généralement de façon séquentielle, une tâche à la fois. Un système multi-agent peut nativement traiter plusieurs tâches en parallèle, ce qui accélère les résultats et améliore l’expérience utilisateur.
• Robustesse : Si votre système à agent unique ne parvient pas à résoudre un problème précis, c’est une impasse. À l’inverse, les systèmes multi-agents peuvent aborder le problème selon plusieurs angles, augmentant ainsi les chances de succès.
• Résolution de problèmes complexes : Les systèmes multi-agents combinent nativement les forces de différents agents pour traiter des problèmes complexes plus efficacement qu’un agent seul. C’est particulièrement pertinent pour les tâches qui exigent un ensemble de compétences, comme l’analyse de données en plusieurs étapes ou les workflows complexes.

Exemple concret

Notre application d’exemple comprend 3 agents :

• Agent conversationnel : Gère les interactions avec l’utilisateur et la délégation des tâches
• Agent Gmail : Spécialisé dans les opérations email (lecture, rédaction, envoi)
• Agent Slack : Gère les interactions avec la plateforme de messagerie

Cette séparation permet à chaque agent de conserver des instructions ciblées et des capacités spécialisées, sans créer un système fourre-tout ingérable.

Ils sont également entièrement interconnectés, ce qui signifie que n’importe quel agent peut passer le contrôle à un autre, créant un système flexible capable de gérer des workflows complexes en plusieurs étapes.

Définition et connexions des agents

Les agents qui appellent des outils doivent y avoir accès pour résoudre les tâches qui leur sont assignées. Nous y parvenons grâce à la bibliothèqueagents-arcade d’Arcade, qui gère l’authentification et les appels d’outils de façon transparente :

google_tools = await get_arcade_tools(client, tools=["Google_ListEmails", "Google_SendEmail"])
slack_tools = await get_arcade_tools(client, tools=["Slack_ListUsers", "Slack_SendDmToUser"])

Le mécanisme clé qui permet la collaboration multi-agent est le handoff (la capacité d’un agent à passer le contrôle à un autre lorsqu’il rencontre une tâche hors de son domaine). Chaque agent reçoit un nom et des instructions sur ce qu’il doit faire. Nous le connectons également aux autres agents via la propriétéhandoffs et exposons ses capacités aux autres agents grâce àhandoff_description.

# Declare a new agent
google_agent = Agent(
    name="Google Agent",
    instructions="You are a helpful assistant that can assist using tools"
                 " to manage a Google account, contacts, and inbox.",
    handoff_description="An agent equipped with Google tools",
    model=os.environ["OPENAI_MODEL"],
    tools=google_tools, # Provide access to relevant tools
    hooks=CustomAgentHooks(display_name="Google Agent")
)

slack_agent = Agent(
    name="Slack agent",
    instructions="You are a helpful assistant that can assist using tools"
                 " to interact with Slack."
                 " You have tools to manage channels and send DMs.",
    handoff_description="An agent equipped with Slack tools",
    model=os.environ["OPENAI_MODEL"],
    tools=slack_tools,
    hooks=CustomAgentHooks(display_name="Slack Agent"),
)

triage_agent = Agent(
    name="conversation_agent",
    instructions="You are a helpful assistant that can help with everyday"
                 " tasks. You can handoff to another agent with access to"
                 " Gmail tools if needed. You can also handoff to an agent"
                 " with Slack tools if needed. Handoff to the appropriate"
                 " agent based on the services required.",
    model=os.environ["OPENAI_MODEL"],
    handoffs=[google_agent, slack_agent], # connect it to other agents
    hooks=CustomAgentHooks(display_name="Conversation Agent")
)

# Buld remaining connections
google_agent.handoffs.extend([triage_agent, slack_agent])
slack_agent.handoffs.extend([triage_agent, google_agent])

La topologie finale ressemble à ceci, où les flèches représentent les handoffs possibles.

Contrôles human-in-the-loop

Un aspect critique des systèmes multi-agents, surtout ceux qui gèrent des opérations sensibles comme l’envoi d’emails ou de messages, est la mise en place de contrôles human-in-the-loop.

# Example of human approval implementation
async def confirm_tool_usage(context, tool_arguments, tool_name, callable):
    """Request human approval before executing sensitive operations"""
    print(f"About to call {tool_name} with these arguments:")
    print(json.dumps(json.loads(tool_arguments), indent=2))

    confirmation = input("Approve this action? (y/n): ")
    if confirmation.lower() == "y":
        return await callable(context, tool_arguments)
    else:
        raise UserDeniedToolCall(tool_name)

Cette approche garantit que les utilisateurs gardent le contrôle sur les actions automatisées, évitant les opérations non souhaitées tout en profitant des capacités du système.

Opérations multi-tours avec Gmail et Slack

Un système multi-agent révèle tout son potentiel lors d’opérations complexes en plusieurs tours, à travers différents services. Voici un exemple de workflow :

1. L’utilisateur demande : « Récupère mes 5 emails les plus récents, résume-les et envoie-moi les résumés sur Slack »
2. L’agent conversationnel identifie les composantes email et Slack
3. Handoff vers l’agent Gmail pour récupérer les emails récents
4. L’agent Gmail traite les emails et extrait les informations clés
5. Handoff vers l’agent Slack avec le contenu résumé
6. Validation humaine demandée avant l’envoi du message Slack
7. Message envoyé après validation

Cette demande en apparence simple mobilise plusieurs agents spécialisés qui collaborent, chacun gérant ses tâches propres tout en conservant le contexte global de la conversation.

Le composant Gmail est particulièrement important : il doit gérer diverses opérations email comme la recherche, la lecture et la rédaction de messages. Si vous souhaitez créer un agent Gmail autonome avant de vous attaquer à un système multi-agent complet, consultez notre guide :Comment créer un agent IA pour Gmail : guide complet 2025.

Auth des agents : résoudre le défi de l’authentification multi-service

L’authentification des agents représente l’un des obstacles les plus importants lors de la création de systèmes multi-services. Chaque agent nécessitant un accès à des services externes comme Gmail ou Slack doit disposer des bonnes credentials, ce qui soulève plusieurs défis techniques :

1. Complexité OAuth : Chaque service implémente les flux OAuth différemment
2. Gestion des tokens : Stocker, renouveler et gérer les tokens d’accès de façon sécurisée
3. Expérience utilisateur : Créer des expériences d’authentification fluides sans perturber les workflows
4. Identité cross-service : Maintenir une identité cohérente à travers plusieurs services

L’utilisation d’une plateforme comme Arcade.dev peut considérablement simplifier l’implémentation de l’auth des agents :

# Example of streamlined agent authentication
async def auth_tool(client, tool_name, user_id):
    """Authenticate an agent with external services"""
    result = await client.tools.auth.authorize(tool=tool_name, user_id=user_id)

    if result.status != "completed":
        print(f"Please complete authentication: {result.url}")

    await client.tools.auth.wait_for_completion(result)

Cette approche gère la complexité des sessions authentifiées sur plusieurs services, permettant aux développeurs de se concentrer sur la logique des agents plutôt que sur la gestion de l’authentification. Pour les applications d’entreprise nécessitant une gestion des identités plus poussée, l’implémentation duSSO pour agents peut apporter des contrôles de sécurité et d’administration supplémentaires.

Applications concrètes des systèmes multi-agents

L’exemple d’intégration Gmail-Slack ne montre qu’un cas d’usage parmi d’autres. Voici quelques applications pratiques :

1. Service client : Routage des demandes vers des agents spécialisés gérant différents aspects du support
2. Aide à la recherche : Combinaison d’agents spécialisés dans la recherche, l’analyse de données et la génération de contenu
3. Automatisation des workflows : Création de systèmes qui gèrent des processus métier en plusieurs étapes sur différentes plateformes
4. Productivité personnelle : Assistants qui coordonnent les tâches entre emails, calendriers et plateformes de communication

Créer votre propre système multi-agent

Si vous souhaitez implémenter votre propre système multi-agent avec l’OpenAI Agents SDK, nous avons créé un tutoriel vidéo complet qui vous guide pas à pas dans la construction du système Gmail-Slack décrit dans cet article.

Le tutoriel couvre :

• Configurer l’environnement de l’OpenAI Agents SDK
• Implémenter les handoffs entre agents
• Mettre en place des contrôles human-in-the-loop
• Gérer l’authentification entre services
• Déboguer les interactions multi-agents

Regarder notre tutoriel complet sur les systèmes multi-agents sur YouTube →

L’avenir des systèmes multi-agents

À mesure que les grands modèles de langage continuent d’évoluer, les architectures multi-agents deviendront de plus en plus importantes pour créer des systèmes IA pratiques et spécialisés. La capacité à décomposer des tâches complexes en composants spécialisés qui collaborent de façon fluide représente une avancée majeure vers des assistants IA plus capables et plus fiables.

En maîtrisant les concepts fondamentaux des handoffs entre agents, des contrôles human-in-the-loop et des opérations multi-tours, les développeurs peuvent créer des systèmes IA qui dépassent les limites des approches à agent unique.

Créez un compte arcade.dev pour commencer à construire. →