ArcticSwarm : Snowflake AI révolutionne la recherche multi-agents

Introduction

Le 2 juin 2026, Snowflake AI Research a publié un article de blog technique qui a attiré l'attention de la communauté technologique. L'article présente ArcticSwarm, un système multi-agents novateur conçu pour transformer la manière dont les entreprises mènent des recherches approfondies. Ce système se distingue par sa capacité à intégrer des données structurées provenant de bases de données SQL avec des informations non structurées issues de pages web, de documents et d'autres sources externes. ArcticSwarm répond à un défi majeur de l'intelligence artificielle en entreprise : la combinaison efficace de preuves structurées et non structurées.

Contrairement aux approches traditionnelles qui reposent sur un seul agent de raisonnement, souvent sujet à des biais de confirmation, ou sur des groupes d'agents mal coordonnés qui peuvent rapidement converger vers des conclusions similaires, ArcticSwarm coordonne jusqu'à 16 agents spécialisés. Ces agents sont dédiés à des tâches spécifiques telles que la navigation, le codage, l'analyse SQL et le raisonnement. Le système utilise un Système de Bulletin de Coordination (BBS) pour orchestrer ces agents. Le processus se déroule en trois étapes de gouvernance distinctes :

• Mode 1 — Isolation : Les agents explorent indépendamment le problème. Ils peuvent partager leurs découvertes sur le bulletin, mais ne peuvent pas consulter les contributions des autres agents, ce qui favorise une exploration diversifiée.

• Mode 2 — Collaboration : Les agents ont la possibilité de lire et d'écrire sur le bulletin, ce qui leur permet de croiser les preuves, de valider les conclusions et de résoudre les incohérences.

• Mode 3 — Synthèse : Une Hybrid Evidence Gate s'assure qu'un nombre suffisant de preuves SQL et web a été collecté avant que l'orchestrateur ne produise le rapport final, réduisant ainsi les conclusions non étayées et les hallucinations.

Selon Snowflake AI Research, ArcticSwarm améliore considérablement les performances des tâches de recherche hybride en entreprise par rapport aux approches à agent unique, démontrant ainsi la valeur de l'exploration indépendante, de la vérification collaborative et de la synthèse régulée par des preuves.

Ce qui rend ArcticSwarm différent

Les recherches menées par Snowflake ont mis en lumière trois pièges structurels fréquents dans les configurations multi-agents traditionnelles :

• Le piège de l'exploration : Les agents partagent leurs pistes trop tôt, ce qui conduit à un consensus prématuré.

• Le piège de l'exploitation : En l'absence d'une évaluation structurée, les agents ne peuvent pas s'engager en toute confiance dans leurs réponses.

• Le piège de la fiabilité : Les fusions non vérifiées de données SQL et de prose web entraînent des hallucinations.

ArcticSwarm surmonte ces obstacles grâce à ses trois modes de gouvernance appliqués via un bulletin central :

| Mode | Nom du Mode | Règle | |--------|-----------------|--------------------------------------------------------------------------------------------------------------------------------------------| | Mode 1 | Isolation | Les agents peuvent ÉCRIRE sur le BBS mais ne peuvent pas LIRE, forçant une exploration indépendante et empêchant le biais des découvertes d'autres agents. | | Mode 2 | Collaboration | Les agents peuvent LIRE et ÉCRIRE sur le BBS, permettant le croisement des preuves, le partage des connaissances et le raffinement collaboratif des découvertes. | | Mode 3 | Synthèse | Seul l'Orchestrateur écrit sur le BBS, consolidant les découvertes vérifiées dans le rapport final validé. |

La Hybrid Evidence Gate empêche la sortie finale tant que des seuils de preuves configurables ne sont pas atteints, par exemple, au moins deux publications de preuves SQL, deux publications de preuves web, et une synthèse inter-domaines.

Aperçu de l'architecture

L'architecture d'ArcticSwarm est conçue pour être complète et intégrée :

• Architecture ArcticSwarm de bout en bout : Les requêtes sont traitées par un orchestrateur FastAPI qui génère des agents isolés pour des tâches spécifiques comme la navigation, le codage et le raisonnement. Ces agents sont coordonnés via un BBS Gated soutenu par Redis, utilisant trois modes de gouvernance, et produisent des rapports de recherche régulés par des preuves — tout cela est alimenté par un seul appel LLM gratuit.

• Trois services conteneurisés : Redis BBS pour la coordination, FastAPI pour l'orchestration, et Streamlit pour l'interface utilisateur.

• Connexion ArcticSwarm — construite avec Streamlit et déployée via Docker Compose.

L'innovation clé : Récupérer puis analyser

L'architecture originale d'ArcticSwarm repose sur l'appel d'outils LLM pour l'interaction agent-outil. Cependant, sur des LLM gratuits comme Groq, l'appel d'outils s'est avéré peu fiable. Les agents avaient tendance à halluciner des preuves, fabriquant des URL et des résultats SQL, car le LLM n'exécutait en réalité aucun outil.

Pour résoudre ce problème, un modèle Récupérer puis analyser a été mis en place. Plutôt que de suivre le processus traditionnel où le LLM décide d'appeler un outil, exécute l'outil, puis analyse le résultat, le nouveau modèle fonctionne ainsi :

• L'agent exécute directement l'outil, les résultats réels sont postés sur le BBS, et un seul LLM synthétise toutes les preuves.

Cela signifie que :

• BrowsingAgent appelle directement l'API de DuckDuckGo sans passer par un appel LLM.

• CodingAgent exécute SQL directement contre Snowflake, sans appel LLM.

• Un seul appel LLM est effectué par requête de recherche pour la synthèse finale.

Le résultat est que les URL proviennent de recherches web réelles, éliminant ainsi les sources hallucinées.

Plongée dans l'implémentation

1. Le Système de Bulletin de Coordination

Le BBS est le cœur d'ArcticSwarm. Toutes les communications inter-agents passent par lui, avec un accès structuré :

class GatedBBS:
    async def post(self, task_id, agent_id, post, current_mode):
        """Mode 3 : Seul l'orchestrateur peut écrire."""
        if current_mode == GovernanceMode.SYNTHESIS and agent_id != "orchestrator":
            raise PermissionError("Mode 3 : Seul l'orchestrateur peut publier")
        # ... écrire dans Redis

    async def read(self, task_id, agent_id, current_mode):
        """Mode 1 : Accès en lecture REFUSÉ pour les agents."""
        if current_mode == GovernanceMode.WRITE_ONLY and agent_id != "orchestrator":
            raise PermissionError("Mode 1 : Les agents ne peuvent pas lire le BBS")
        # ... lire depuis Redis

Ce n'est pas juste une instruction de prompt — c'est une application architecturale. Un agent en Mode 1 ne peut physiquement pas lire le BBS, peu importe ce que le LLM "décide".

1. L'Agent de Navigation (Recherche Web réelle)

class BrowsingAgent(BaseAgent):
    async def run(self, instruction: str) -> list[BBSPost]:
        # Extraire la requête principale de l'instruction
        search_query = instruction.split("on the web:")[-1].strip()
        
        # Étape 1 : Exécuter la recherche DuckDuckGo directement (PAS D'APPEL LLM)
        browser = WebBrowserTool()
        search_results = await browser.web_search(search_query, num_results=5)
        
        # Étape 2 : Formater les résultats comme des preuves structurées
        findings = "\n".join(
            f"- [{r['title']}]({r['url']}): {r['snippet']}" for r in search_results
        )
        
        # Étape 3 : Publier les RÉSULTATS RÉELS sur le BBS avec des URL réelles
        post = BBSPost(evidence_type=EvidenceType.WEB_FINDING, […] 

L'architecture ArcticSwarm permet ainsi une recherche plus efficace et fiable, en intégrant des mécanismes de gouvernance qui favorisent l'exploration indépendante et la validation collaborative des résultats.