Résumé Technique : AsyncFC – Concurrence sans Modifications du Modèle

Énoncé du Problème

Les agents modernes de Modèles de Langage (LLM) reposent sur l'appel de fonctions (utilisation d'outils) pour interagir avec des API externes et exécuter des actions. Cependant, la sémantique d'exécution prédominante est strictement synchrone : le processus de décodage du modèle est bloqué jusqu'à ce qu'un appel de fonction se termine et que son résultat soit ajouté à l'historique de la conversation. Cette sérialisation crée un goulot d'étranglement significatif, augmentant la latence de bout en bout, en particulier dans les flux de travail impliquant plusieurs appels d'outils séquentiels ou parallèles.

Les approches existantes pour atténuer ce problème nécessitent souvent d'altérer le protocole d'appel de fonctions, de modifier l'architecture du modèle, ou de transférer la complexité de la gestion de la concurrence vers le modèle lui-même. Ces changements peuvent compromettre la sémantique standard appel-retour, introduire des conditions de course, ou nécessiter un ajustement fin supplémentaire.

Méthodologie : AsyncFC

Les auteurs présentent AsyncFC, un cadre d'exécution pur qui découple le décodage des LLM de l'exécution des fonctions sans exiger de modifications aux modèles sous-jacents, aux implémentations de fonctions ou au protocole standard d'appel de fonctions synchrone.

Mécanismes Principaux

1. Décodage basé sur des Futurs :

   • AsyncFC transforme les schémas de fonctions synchrones pour prendre en charge les entrées et sorties à valeurs futures.
   • Lorsque le modèle émet un appel de fonction, le runtime déplace l'exécution vers un exécuteur backend et renvoie immédiatement un marqueur symbolique de futur (un résultat non résolu) au modèle.
   • Cela permet au modèle de continuer à décoder les tours suivants sans attendre la fin de la fonction, satisfaisant le protocole standard appel-retour tout en permettant un chevauchement décodage-exécution.
   • Le cadre transforme automatiquement les entrées de fonctions pour accepter soit des valeurs concrètes, soit des identifiants de futur, permettant au modèle de raisonner sur des résultats non résolus en tant qu'arguments pour les appels subséquents.

2. Intégration des Résultats Pilotée par Événements :

   • Une fois l'exécution d'une fonction terminée, AsyncFC intègre proactivement le résultat résolu dans le contexte du modèle aux limites de tours en insérant des messages utilisateur qui lient l'identifiant de futur à sa valeur.
   • Si le modèle exige explicitement une valeur concrète (par exemple, via un appel await_future), le runtime détecte cette intention tôt pour minimiser les pénalités de latence, pouvant utiliser des flux de décodage parallèles pour réduire la surcharge.

3. Ordonnancement Conscient des Dépendances :

   • Pour exécuter des fonctions en parallèle en toute sécurité, AsyncFC emploie un ordonnanceur qui gère la concurrence basée sur les dépendances de ressources.
   • Comportement par Défaut : Sans annotations, l'ordonnanceur sérialise l'exécution de manière conservatrice pour garantir la correction.
   • Comportement Optimisé : Les développeurs peuvent fournir des annotations de dépendance légères (via des décorateurs) spécifiant les ensembles de lecture/écriture pour les ressources de fonction. L'ordonnanceur les utilise pour dériver un DAG de dépendances de fonctions spécifique à la tâche, permettant l'exécution concurrente uniquement lorsque les dépendances sont satisfaites (c'est-à-dire sans accès conflictuel à l'état).
   • Cette approche débloque le parallélisme inter-fonctions tout en maintenant des mises à jour d'état déterministes et en évitant les conditions de course.

4. Gestion des Erreurs :

   • Si une fonction échoue, AsyncFC annule tous les appels subséquents dépendants transitivement tout en laissant les appels indépendants intacts. Les messages d'erreur sont injectés dans le contexte pour déclencher des tours de récupération.

Contributions Clés

• Asynchronicité Compatible avec le Protocole : AsyncFC est le premier cadre à permettre l'appel de fonctions asynchrone et le parallélisme inter-fonctions tout en préservant strictement le protocole standard synchrone appel-retour attendu par les LLM prêts à l'emploi.
• Zéro Modification du Modèle : Le système ne nécessite aucun ajustement fin, aucun changement architectural, ni aucune modification des implémentations de fonctions existantes. Il opère entièrement au niveau de la couche d'exécution.
• Découverte de Raisonnement Natif : Ce travail démontre que les LLM possèdent une capacité native à raisonner sur des marqueurs symboliques de futur représentant des résultats d'exécution non résolus, permettant un paradigme asynchrone pour l'interaction modèle-outil sans entraînement explicite.
• Généralisabilité : Le cadre s'étend au-delà de l'utilisation d'outils externes vers la pensée asynchrone, où les sous-tâches sont traitées comme des appels de fonctions à longue latence, permettant au modèle principal de coordonner des agents de raisonnement parallèles.

Résultats Expérimentaux

Les auteurs ont évalué AsyncFC sur des benchmarks standards d'appel de fonctions (BFCL v3/v4), des tâches d'ingénierie logicielle (SWE-bench Lite) et du raisonnement multi-sauts (HotpotQA).

• Réduction de la Latence :
  • Recherche Web BFCL v4 : Une accélération de 1,26× par rapport à l'Appel de Fonction Séquentiel et de 1,12× par rapport à l'Appel de Fonction Parallèle sous des latences de fonctions réalistes.
  • SWE-bench Lite : Intégré avec SWE-agent, AsyncFC a atteint une accélération de 1,44× par rapport à l'agent SWE de base et une amélioration statistiquement significative par rapport à une variante d'Appel de Fonction Parallèle.
  • HotpotQA : Une accélération de 1,24× démontrée sur les tâches de raisonnement multi-sauts.
• Préservation de la Précision : Sur tous les benchmarks, AsyncFC n'a montré aucune dégradation statistiquement significative de la précision des tâches par rapport aux bases de référence synchrones. Cela confirme que les modèles peuvent raisonner avec succès sur des futurs non résolus.
• Évolutivité : Les économies de latence ont été montrées comme s'échelonnant avec le temps d'exécution des fonctions. Initialement pilotées par le chevauchement décodage-exécution, les gains sont de plus en plus dominés par le parallélisme inter-fonctions à mesure que les latences des fonctions augmentent.
• Robustesse Inter-Modèles : Le cadre a amélioré avec succès les performances sur différents modèles (GPT-4o, Gemini 3.1 Pro, GPT-5.2) et dans des scénarios avec et sans annotations de dépendance explicites (bien que les annotations produisent des accélérations plus élevées).

Importance et Revendications

L'article revendique qu'AsyncFC adresse un goulot d'étranglement critique dans les flux de travail d'agents en déchargeant la gestion de la concurrence du modèle vers le runtime système. Son importance réside dans trois domaines :

1. Efficacité : Il fournit une solution pratique, prête à l'emploi, pour réduire la latence de bout en bout dans les agents utilisant des outils, en particulier pour les opérations à longue latence, en maximisant le parallélisme exploitable sans compromettre le protocole d'interaction standard.
2. Insight sur les Capacités : Les résultats fournissent des preuves empiriques que les LLM modernes peuvent nativement raisonner sur des futurs symboliques. Cela suggère que la capacité « asynchrone » est une propriété émergente des modèles entraînés sur des artefacts logiciels contenant des motifs asynchrones (par exemple, promesses/futurs), plutôt qu'une fonctionnalité nécessitant une intervention architecturale explicite.
3. Conception Système : En introduisant une sémantique explicite d'ordre d'exécution et un ordonnancement conscient des dépendances, AsyncFC résout les ambiguïtés présentes dans les API d'appel de fonctions parallèles existantes, réduisant les modes de défaillance causés par les conditions de course tout en permettant un parallélisme sûr et respectueux des dépendances.

Les auteurs concluent que ce motif d'interaction modèle-outil asynchrone offre un nouveau paradigme pour concevoir des flux de travail d'agents flexibles et efficaces, applicable à la fois à l'utilisation d'outils externes et aux processus de raisonnement internes.