Maîtriser les agents IA parallèles : dynamisez vos workflows grâce à l'exécution concurrente

Le paysage de l’intelligence artificielle évolue rapidement, dépassant les interactions à requête unique pour s’orienter vers des workflows sophistiqués et multi-étapes orchestrés par des agents IA. Ces agents, alimentés par de grands modèles de langage (LLM), peuvent planifier de manière autonome, utiliser des outils et itérer afin de résoudre des problèmes complexes. Cependant, à mesure que la complexité des tâches augmente, un goulot d’étranglement critique apparaît : le traitement séquentiel. Un workflow où l’Agent A doit attendre l’Agent B, qui à son tour attend l’Agent C, devient rapidement inefficace et lent.

Ce défi a donné naissance au paradigme des agents IA parallèles. Dans ce modèle, plusieurs agents ou sous-tâches sont exécutés simultanément, agissant de concert pour atteindre un objectif global unique. Cette approche n’est pas une simple optimisation : elle constitue la clé pour libérer le véritable potentiel des systèmes multi-agents, conduisant à des applications IA plus rapides, plus robustes et plus complexes. Cet article explore l’architecture, les avantages et propose des exemples de code pratiques dans trois frameworks populaires : LangGraph, l’Agent Development Kit (ADK) de Google et CrewAI.

La puissance du parallélisme : pourquoi cela compte

Le passage de l’exécution séquentielle à l’exécution parallèle offre des avantages profonds qui transforment fondamentalement le profil de performance des systèmes agentiques.

Vitesse et efficacité

Le bénéfice le plus immédiat est la réduction spectaculaire de la latence. Pour des tâches telles que la recherche approfondie ou la génération de code complexe, où plusieurs sources ou composants doivent être analysés, l’exécution concurrente de ces étapes peut réduire le temps total d’exécution d’un facteur proportionnel au nombre de branches parallèles. Cela est crucial pour les applications nécessitant une réactivité quasi temps réel.

Gestion de la complexité

Le parallélisme permet de décomposer efficacement de grands problèmes complexes. Une tâche unique et monolithique peut être divisée en sous-tâches plus petites et gérables, intrinsèquement indépendantes. Par exemple, une tâche d’analyse financière peut envoyer simultanément des agents pour collecter des données boursières, lire le sentiment des actualités et analyser les rapports trimestriels. Cette stratégie « diviser pour mieux régner » simplifie la conception des agents individuels tout en permettant au système de gérer un degré de complexité bien plus élevé.

Robustesse et validation croisée

Une architecture parallèle introduit intrinsèquement un mécanisme de validation croisée et accroît la robustesse. En faisant aborder le même problème par plusieurs agents sous différents angles — éventuellement avec différents outils ou différentes instructions LLM — le système peut comparer et concilier leurs conclusions. Cette redondance contribue à atténuer le risque qu’un agent unique hallucine ou échoue, conduisant à un résultat final plus fiable.

Concepts avancés de parallélisme

Si l’exécution parallèle simple est puissante, les systèmes multi-agents avancés exploitent des concepts plus sophistiqués :

• Parallélisme conditionnel : la capacité de décider dynamiquement quelles branches d’un workflow doivent s’exécuter en parallèle en fonction du résultat d’une étape précédente. Par exemple, un agent planificateur peut décider d’exécuter deux agents de recherche en parallèle uniquement si la requête de recherche initiale est ambiguë.
• Forking dynamique : créer un nombre arbitraire d’agents parallèles à l’exécution. Cela est crucial pour des tâches telles que le traitement d’une liste de documents ou l’analyse d’un lot de points de données, où le nombre de tâches parallèles n’est pas fixé à l’avance.
• Gestion de la mémoire partagée : dans des scénarios complexes, les agents parallèles peuvent avoir besoin de lire et d’écrire simultanément dans un état partagé. Cela nécessite une mise en œuvre soigneuse des contrôles de concurrence (verrous ou opérations atomiques) pour éviter les conditions de course et garantir l’intégrité des données. Les frameworks abstraient cette complexité, mais comprendre le mécanisme sous-jacent est essentiel pour le débogage et la mise à l’échelle.

Plongée architecturale : MAS séquentiel vs parallèle

Un système multi-agents (MAS) est défini par ses composants fondamentaux : les agents (LLM dotés de capacités de raisonnement), les outils qu’ils peuvent utiliser, la mémoire qui maintient l’état, et l’orchestrateur qui gère le flux. La différence entre un MAS séquentiel et un MAS parallèle réside entièrement dans la couche d’orchestration.

L’orchestrateur est le composant central qui permet le parallélisme. Il doit être capable de réaliser le forking, la gestion de l’état et la jonction.

Mise en œuvre pratique : une approche multi-framework

Le concept d’agents parallèles est implémenté différemment selon les frameworks, mais le principe fondamental reste le même : exécuter des tâches indépendantes de manière concurrente. Nous explorerons comment cela est réalisé dans trois frameworks majeurs : LangGraph, Google ADK et CrewAI.

1. LangGraph : parallélisme basé sur les graphes

Le framework LangGraph, une extension de LangChain, est parfaitement adapté à la création de ces applications stateful et multi-acteurs. Il modélise le workflow sous forme de graphe, où les nœuds sont des agents ou des fonctions, et les arêtes définissent le flux d’exécution. La clé pour implémenter le parallélisme dans LangGraph consiste à définir plusieurs arêtes sortantes depuis un même nœud (ou depuis le nœud START) vers les nœuds qui doivent s’exécuter en concurrence.

Exemple de code : agents parallèles avec LangGraph

Cet exemple exécute deux agents distincts en parallèle pour répondre à une requête unique, puis fusionne leurs résultats.

import os
from typing import TypedDict
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_google_genai import ChatGoogleGenerativeAI # For direct Gemini usage
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.prompts import PromptTemplate
from langchain_community.tools import WikipediaQueryRun, DuckDuckGoSearchRun
from langchain_community.utilities import WikipediaAPIWrapper
from langgraph.graph import StateGraph, END, START

# --- 1. Define Graph State (Shared Memory) ---
class GraphState(TypedDict):
    input: str
    agent_a_result: str
    agent_b_result: str
    output: str

# --- 2. Define Agent Nodes (Functions) ---
# Note: In a real implementation, you would initialize the LLM here:
# llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash") 
# and use it within the run_agent_a/b functions.

def run_agent_a(state: GraphState) -> dict:
    # ... Agent A execution logic using the LLM ...
    return {"agent_a_result": "Result from Agent A (e.g., historical data)"}

def run_agent_b(state: GraphState) -> dict:
    # ... Agent B execution logic using the LLM ...
    return {"agent_b_result": "Result from Agent B (e.g., current events)"}

def merge_results(state: GraphState) -> dict:
    # ... Merging logic, potentially using a final LLM call ...
    return {"output": f"Merged: {state['agent_a_result']} and {state['agent_b_result']}"}

# --- 3. Build the LangGraph ---
workflow = StateGraph(GraphState)
workflow.add_node("run_agent_a", run_agent_a)
workflow.add_node("run_agent_b", run_agent_b)
workflow.add_node("merge_results", merge_results)

# The key to parallelism: Add two edges from START
workflow.add_edge(START, "run_agent_a")
workflow.add_edge(START, "run_agent_b")

# The key to joining: Add edges from parallel nodes to a single merge node
workflow.add_edge("run_agent_a", "merge_results")
workflow.add_edge("run_agent_b", "merge_results")
workflow.add_edge("merge_results", END)

app = workflow.compile()

Explication du code :

• GraphState : ce TypedDict est la source unique de vérité. Les agents parallèles écrivent dans des clés distinctes (agent_a_result, agent_b_result) afin d’éviter les conflits.
• Arêtes parallèles (START vers les agents) : en définissant plusieurs arêtes sortantes depuis le nœud START, LangGraph exécute automatiquement les nœuds connectés (run_agent_a et run_agent_b) de manière concurrente.
• Arêtes de jonction (agents vers merge_results) : le nœud merge_results possède deux arêtes entrantes. Le comportement par défaut de LangGraph consiste à attendre que toutes les arêtes entrantes soient terminées avant d’exécuter le nœud, garantissant ainsi que les deux résultats parallèles sont disponibles pour la fusion.

Cette approche basée sur les graphes offre un contrôle explicite et visuel du flux parallèle, ce qui la rend particulièrement adaptée au raisonnement agentique complexe et multi-étapes.

2. Google ADK : le ParallelAgent

L’Agent Development Kit (ADK) de Google fournit une classe dédiée ParallelAgent, un agent de workflow conçu pour exécuter ses sous-agents en concurrence. C’est l’idéal pour les scénarios où les tâches sont indépendantes et où la vitesse est critique.

Exemple de code : recherche web parallèle avec Google ADK

Cet exemple met en place deux agents de recherche spécialisés et les exécute en parallèle, suivis d’un agent final de synthèse.

# Conceptual example based on ADK documentation.
from adk.agents.workflow_agents import ParallelAgent, SequentialAgent
from adk.agents.llm_agent import LlmAgent
from adk.tools import GoogleSearchTool # Example tool

# Define the model to be used
GEMINI_MODEL = "gemini-2.5-flash"

# --- 1. Define Researcher Sub-Agents (LlmAgents) ---
# Each agent is specialized and configured to store its result in a specific state key
researcher_agent_1 = LlmAgent(
    name="RenewableEnergyResearcher",
    model=GEMINI_MODEL, # Explicitly set the model
    instruction="Research the latest advancements in renewable energy.",
    tools=[GoogleSearchTool()],
    output_key="renewable_energy_result" # Key for result storage
)

researcher_agent_2 = LlmAgent(
    name="EVResearcher",
    model=GEMINI_MODEL, # Explicitly set the model
    instruction="Research the latest developments in electric vehicle technology.",
    tools=[GoogleSearchTool()],
    output_key="ev_technology_result"
)

# --- 2. Create the ParallelAgent (The Orchestrator) ---
parallel_research_agent = ParallelAgent(
    name="ParallelWebResearchAgent",
    sub_agents=[researcher_agent_1, researcher_agent_2],
    description="Runs multiple research agents in parallel."
)

# --- 3. Define the Merger Agent (Sequential Step) ---
merger_agent = LlmAgent(
    name="SynthesisAgent",
    model=GEMINI_MODEL, # Explicitly set the model
    instruction="Synthesize the findings from {renewable_energy_result} and {ev_technology_result} into a single report.",
    # Note: The input instruction implicitly uses the results stored by the parallel agents
)

# --- 4. Create the SequentialAgent to orchestrate the flow ---
# This ensures the parallel step runs first, followed by the merger.
sequential_pipeline_agent = SequentialAgent(
    name="ResearchAndSynthesisPipeline",
    sub_agents=[parallel_research_agent, merger_agent]
)

Explication du code :

• model=GEMINI_MODEL : le modèle est défini explicitement pour chaque LlmAgent, garantissant l’utilisation du modèle rapide et efficace gemini-2.5-flash pour les tâches de recherche parallèles.
• LlmAgent avec output_key : chaque sous-agent est un LlmAgent qui, à la fin de son exécution, écrit automatiquement sa sortie finale dans l’état partagé de la session via la output_key spécifiée.
• ParallelAgent : cet agent de workflow non LLM est le cœur du parallélisme. Il prend simplement sa liste de sub_agents et les exécute tous en concurrence. Il attend que tous se terminent avant d’être considéré comme achevé.
• SequentialAgent : cet agent est utilisé pour imposer l’opération de jonction. En plaçant le parallel_research_agent en premier et le merger_agent en second, le système garantit que la fusion ne s’exécute qu’après l’achèvement de l’étape parallèle et l’écriture de tous les résultats dans l’état partagé.

Cette séparation claire des préoccupations — exécution parallèle gérée par ParallelAgent et contrôle séquentiel du flux par SequentialAgent — rend les workflows ADK hautement modulaires.

3. CrewAI : exécution asynchrone des tâches

CrewAI réalise le parallélisme au niveau des tâches grâce à l’exécution asynchrone. N’importe quelle tâche peut être marquée pour une exécution concurrente en définissant async_execution=True.

Exemple de code : tâches parallèles avec CrewAI

Cet exemple présente deux tâches qui s’exécuteront en concurrence, suivies d’une tâche séquentielle finale qui synthétise les résultats.

# Conceptual example based on CrewAI documentation.
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool # Example tool

# --- 1. Define Agent ---
researcher = Agent(
    role='Senior Research Analyst',
    goal='Gather and synthesize market and competitor data for a new product launch.',
    backstory='Expert in rapid, multi-source data collection and executive summary writing.',
    llm="gemini-2.5-flash", # Explicitly set the model
    tools=[SerperDevTool()],
    verbose=True
)

# --- 2. Define Parallel Tasks ---
market_task = Task(
    description='Analyze the current market trends for AI agents, focusing on growth rate and key adoption drivers.',
    agent=researcher,
    expected_output='A 3-point summary of current market trends and growth projections.',
    async_execution=True # KEY: Marks this task for concurrent execution
)

competitor_task = Task(
    description='Identify and summarize the top 3 competitors in the AI agent space, detailing their core product and market share.',
    agent=researcher,
    expected_output='A list of 3 competitors with a one-sentence description and estimated market share.',
    async_execution=True # KEY: Marks this task for concurrent execution
)

# --- 3. Define Sequential Synthesis Task (The Join) ---
synthesis_task = Task(
    description='Synthesize the market and competitor analysis into a single executive summary report for the CEO.',
    agent=researcher,
    expected_output='A final executive summary report, formatted in Markdown.',
    # KEY: The context explicitly tells the agent to wait for the results of the parallel tasks
    context=[market_task, competitor_task] 
)

# --- 4. Form the Crew ---
research_crew = Crew(
    agents=[researcher],
    tasks=[market_task, competitor_task, synthesis_task],
    process=Process.sequential # The tasks are processed in the order they are listed
)

# To run the crew:
# result = research_crew.kickoff()

Explication du code :

• llm="gemini-2.5-flash" : le modèle est défini explicitement dans la définition de l’Agent, garantissant que le modèle rapide et efficace gemini-2.5-flash est utilisé pour toutes les tâches exécutées par cet agent.
• async_execution=True : il s’agit du mécanisme central du parallélisme dans CrewAI. Lors du lancement de la crew, toute tâche marquée par ce flag sera exécutée de manière concurrente.
• context=[market_task, competitor_task] : c’est le mécanisme explicite de jonction. La synthesis_task ne démarrera pas tant que les tâches listées dans son context ne seront pas terminées. L’agent affecté à la tâche de synthèse utilisera alors les sorties des tâches parallèles comme entrée.

Cette approche du parallélisme centrée sur les tâches est très intuitive pour définir des workflows collaboratifs où plusieurs informations doivent être collectées avant qu’une action finale unique ne soit entreprise.

Conclusion

L’avenir de l’automatisation par l’IA est collaboratif et concurrent. En comprenant les différentes approches du parallélisme proposées par des frameworks tels que LangGraph, Google ADK et CrewAI, les développeurs peuvent choisir l’outil adapté à chaque tâche. Qu’il s’agisse du forking explicite basé sur les graphes de LangGraph, du ParallelAgent dédié de l’ADK ou de l’exécution asynchrone des tâches de CrewAI, maîtriser l’exécution concurrente est l’étape essentielle suivante pour construire la prochaine génération d’applications IA intelligentes et performantes. Commencez dès aujourd’hui à expérimenter avec les agents parallèles pour dynamiser vos workflows.

---