AgentHands : Génération de gestes de la main interactifs pour des conversations d'agents ancrées spatialement en XR

AgentHands : Génération de gestes de la main interactifs pour des conversations d’agents spatialement ancrées en XR

Demandez à quiconque a passé du temps dans une salle de réunion en réalité virtuelle ou dans une superposition d’assistant en réalité augmentée, et il vous citera le même décalage : la voix est là, les mots sont clairs, mais le corps est inerte. Les agents synthétiques parlent couramment tandis que leurs mains restent suspendues dans une pose neutre, ne pointant jamais l’objet qu’ils décrivent, n’atteignant jamais le bouton qu’ils expliquent, ne formant jamais un geste qui correspond au rythme de leur discours. Dans une conversation réelle, un tel comportement serait perçu comme robotique, évasif, ou simplement défectueux. En réalité étendue (XR), c’est pire, car l’espace autour de l’agent n’est pas abstrait. Il y a de véritables objets, outils et collaborateurs situés dans l’espace auxquels se référer. Les mains de l’agent ne sont pas une décoration ; elles sont un instrument de pointage, un canal déictique, un moyen de rendre une conversation lisible en trois dimensions.

AgentHands, un projet de recherche de Google Research, cible directement cette lacune. L’approche décrite dans l’article officiel du blog Google Research publié en août 2026 se concentre sur la génération de gestes de la main interactifs pour des conversations d’agents spatialement ancrées en XR. L’accent mis sur « interactif » et « spatialement ancré » est important. Les gestes ne sont pas des animations préfabriquées attendant d’être rejouées ; ils sont générés en réponse au discours de l’agent et à la scène environnante, ce qui signifie que la même phrase peut produire différents mouvements de la main selon que l’agent pointe une tasse à café, une porte, ou rien du tout.

Cet article est un aperçu pratique et technique de ce qu’il faut pour intégrer un tel système dans votre propre pipeline d’agent XR. Il se fonde uniquement sur l’article de recherche public du blog comme base factuelle. Là où l’article décrit des résultats de recherche, je les interpréterai pour un public d’ingénieurs ; là où il ne fournit pas de SDK officiel ni de commandes de publication, je serai explicite à ce sujet. Les étapes d’installation ci-dessous représentent donc une couche d’intégration de référence que vous construiriez autour de l’approche AgentHands, et non un installateur officiel du code de recherche lui-même.

Le problème central : la parole, l’espace et le maillon manquant

La conversation humaine naturelle est multimodale d’une manière que les interfaces textuelles ne capturent jamais. Quand nous disons « mets ça là-bas », nous nous appuyons sur un geste de pointage pour lever l’ambiguïté sur l’objet et l’endroit. Quand nous décrivons un processus, nos mains tracent la forme du processus. Quand nous accentuons un mot, notre main descend en rythme avec la syllabe accentuée. Les modèles de langage, en revanche, produisent des jetons. Ils n’ont aucune compréhension native d’une scène 3D, et ils n’ont pas de cortex moteur.

Le défi en XR est de relier ces deux mondes : le monde discret et symbolique de la parole et le monde continu et géométrique de l’espace physique. Un agent conversationnel en XR doit résoudre trois problèmes simultanément :

1. Que dire — la tâche de génération de langage, généralement gérée par un grand modèle de langage.
2. Où sont les choses — la tâche d’ancrage spatial, généralement gérée par un graphe de scène, une détection d’objets ou des ancres spatiales.
3. Comment bouger — la tâche de génération de gestes, qui est ce qu’AgentHands aborde.

Le troisième problème est le plus négligé. De nombreux agents XR réutilisent soit des animations d’inactivité génériques, soit s’appuient sur le puppetrage humain par suivi des mains, ce qui ne passe pas à l’échelle. D’autres ajoutent la reconnaissance des gestes mais n’ont aucun composant de génération, de sorte que l’agent peut voir les gestes mais ne peut pas les produire. AgentHands inverse ce pipeline : il prend en entrée l’énoncé de l’agent et le contexte spatial, et produit une séquence de gestes à la fois sémantiquement appropriée et physiquement plausible.

Ce qui rend cela particulièrement difficile, c’est que les gestes ne sont pas simplement liés à la signification des mots. Ils sont aussi liés au timing du discours, à l’identité de l’agent et à la physique des mains. Un geste de pointage doit atteindre une cible avec une certaine trajectoire ; un geste de préhension doit anticiper la taille de l’objet ; un geste de battement doit s’aligner sur l’accent prosodique. Obtenir tout cela à des cadences interactives, à l’intérieur d’un casque XR avec un budget d’inférence limité, nécessite un modèle génératif soigneusement conçu que l’agent peut exécuter en temps réel.

Ce qui distingue AgentHands : l’interactivité et l’ancrage

Le mot interactif dans le titre n’est pas accessoire. La plupart des travaux antérieurs sur la génération de gestes co-parole traitent la tâche comme un problème de construction hors ligne : à partir d’une transcription, produire une animation complète de gestes, puis la rejouer. Cette approche échoue en XR parce que la scène n’est pas statique. Un utilisateur peut bouger, un objet peut être déplacé, et une conversation peut être interrompue au milieu d’une phrase. L’agent doit ajuster ses gestes à la volée.

La partie spatialement ancrée est tout aussi importante. Dans un ensemble de données typique de gestes co-parole, un personnage animé fait des gestes dans le vide. L’approche AgentHands conditionne au contraire la génération des gestes sur la scène 3D elle-même. Lorsque l’agent référence un objet, la trajectoire de la main générée doit être influencée par la position, l’orientation et la forme réelles de cet objet. Lorsque l’agent référence une direction, le geste doit refléter la géométrie réelle de la pièce plutôt qu’un balayage générique du bras.

Cela a une conséquence pratique pour la conception du système : la génération de gestes ne peut pas être un module autonome de texte-vers-mouvement. Elle doit être placée à côté d’une couche de compréhension spatiale. Dans un scénario d’intégration, vous fourniriez à l’agent une liste d’objets de la scène avec leurs positions et boîtes englobantes, et le modèle AgentHands utiliserait ces informations, conjointement avec le contexte dialogique, pour décider quand un geste cible un objet spécifique et comment la main doit bouger pour le référencer.

Prérequis

Avant d’arriver au code, établissons ce dont vous avez besoin pour suivre.

• Python 3.10 ou plus récent pour la logique de génération de gestes et d’intégration.
• Un moteur 3D tel que Unity 2022 LTS ou une pile web avec Three.js ou A-Frame, puisque les gestes générés doivent finalement animer un avatar en XR.
• Un casque VR ou AR (optionnel mais fortement recommandé) pour évaluer si les gestes générés semblent réellement ancrés lorsqu’ils sont vus du point de vue de l’utilisateur.
• Un GPU compatible CUDA si vous prévoyez d’exécuter le modèle de génération localement ; sinon, vous pouvez prototyper avec un CPU et un modèle factice léger.
• Un fournisseur de scène spatiale — cela peut être aussi simple qu’une liste JSON de noms d’objets et de transformations, ou aussi complexe qu’un graphe de scène complet provenant de votre framework XR.

Il faut mentionner d’emblée un avertissement important. L’article du blog Google Research décrit la méthode AgentHands et son évaluation, mais il ne publie pas de paquet installable via pip ni de point de contrôle de modèle public. Les commandes ci-dessous configurent donc une intégration de référence que vous pouvez utiliser pour construire l’infrastructure environnante, tester votre plomberie de graphe de scène et valider votre pipeline d’évaluation. Elles utilisent de véritables paquets installables, mais elles ne prétendent pas télécharger un quelconque artefact propriétaire d’AgentHands.

Installation étape par étape

Créons un espace de travail propre et un environnement virtuel. Cela maintient les dépendances isolées de votre installation Python globale.

mkdir agenthands-integration
cd agenthands-integration
python -m venv .venv
source .venv/bin/activate

La commande source s’applique à Linux et macOS ; sous Windows, utilisez .venv\Scripts\activate. Ensuite, mettez à niveau pip et installez les paquets de base que nous utiliserons pendant le développement.

pip install --upgrade pip
pip install numpy

numpy nous donne l’algèbre linéaire nécessaire pour calculer les trajectoires de la main sous forme de vecteurs, ce qui sera utile dans les exemples d’utilisation ci-dessous. Si vous souhaitez brancher plus tard un véritable modèle de gestes, vous aurez probablement aussi besoin d’un framework d’apprentissage profond.

pip install torch --index-url https://download.pytorch.org/whl/cu121

L’indicateur --index-url dirige pip vers les wheels PyTorch compilées pour CUDA 12.1, une configuration courante pour l’inférence accélérée par GPU en 2026. Si votre matériel ou la version de votre pilote diffère, consultez le guide d’installation officiel de PyTorch et ajustez l’URL de l’index en conséquence. Le paquet lui-même est une dépendance réelle et largement utilisée ; le code de recherche d’AgentHands, s’il est publié, reposerait probablement sur lui.

Créez maintenant une structure de projet minimale pour garder l’intégration propre.

mkdir -p agenthands/{scene,gesture,avatar}
touch agenthands/__init__.py config.yaml

Le fichier config.yaml contiendra la configuration de la scène et du modèle. Une configuration YAML minimale pourrait ressembler à ceci :

scene:
  coordinate_system: "left_handed"   # correspond à votre moteur XR
  scale: 1.0
gesture:
  fps: 30
  smoothing: 0.2
avatar:
  id: "narrator"
  hand_model: "full_hand"

Le champ fps détermine combien de frames de gestes par seconde votre boucle de génération cible. C’est un paramètre de conception que vous choisissez, pas un nombre revendiqué par l’article de recherche.

Exemples d’utilisation

L’idée centrale que nous voulons prototyper est une interface simple : l’agent produit un énoncé textuel, le fournisseur de scène fournit une liste d’objets spatialisés, et notre module de gestes décide ce que les mains doivent faire. Ci-dessous se trouve un module Python illustratif qui montre la forme de cette interface.

import numpy as np

class SpatialReference:
    """A named object with a 3D position and a coarse bounding box."""
    def __init__(self, name, position, size):
        self.name = name
        self.position = np.asarray(position, dtype=float)
        self.size = np.asarray(size, dtype=float)

class GestureChannel:
    """Maps an utterance plus a spatial scene to a hand gesture."""
    def __init__(self, agent_position):
        self.agent_position = np.asarray(agent_position, dtype=float)

    def generate(self, utterance, target=None):
        if target is not None:
            return self._point_at(target, emphasis=0.8)
        return self._beat_gesture(utterance)

    def _point_at(self, target, emphasis):
        direction = target.position - self.agent_position
        direction /= np.linalg.norm(direction) + 1e-8
        return {
            "type": "POINT",
            "target_name": target.name,
            "direction": direction.tolist(),
            "emphasis": emphasis,
        }

    def _beat_gesture(self, utterance):
        words = len(utterance.split())
        return {
            "type": "BEAT",
            "beat_count": max(1, int(words / 2)),
            "intensity": min(1.0, words / 20.0),
        }

Dans cette structure, un geste POINT est produit chaque fois que l’agent référence un objet spécifique, et un geste BEAT est produit lorsque l’agent parle sans cible spatiale. La contribution centrale de l’article de recherche est de remplacer les méthodes artisanales _point_at et _beat_gesture par un modèle génératif appris qui produit un mouvement continu de la main et des doigts, conditionné sur les mêmes entrées : le texte de l’énoncé et la géométrie de la scène. L’interface ci-dessus est intentionnellement simple, de sorte que remplacer par un véritable modèle appris est une question d’implémenter generate() comme un appel de modèle plutôt qu’une règle procédurale.

Pour exercer le module, nous avons besoin d’une petite boucle de démonstration qui simule un tour de conversation.

from agenthands.gesture import GestureChannel, SpatialReference

agent = GestureChannel(agent_position=(0.0, 1.6, 0.0))
mug = SpatialReference(
    name="blue_mug",
    position=(1.2, 1.0, -1.5),
    size=(0.1, 0.12, 0.1),
)

my_utterance = "Please hand me the blue mug on the table."
gesture = agent.generate(my_utterance, target=mug)
print(gesture)

Exécuter ceci affichera un dictionnaire décrivant le geste prévu. Dans une vraie boucle XR, ce dictionnaire serait consommé par la couche d’animation de l’avatar, qui retargetterait la pose 3D de la main sur le squelette de votre avatar et la jouerait en synchronie avec l’audio de la parole. La principale idée d’ingénierie est que la couche de génération de gestes doit être agnostique à l’avatar : elle produit une intention spatiale, et la couche d’animation est responsable de réaliser cette intention dans le moteur.

Pour une intégration plus réaliste, vous voudriez également inclure un signal temporel. Les gestes humains sont synchronisés avec la parole, donc votre module de gestes devrait accepter une entrée timestamp ou speech_segment, comme illustré ci-dessous.

def generate_timed(self, utterance, audio_events, target=None):
    """
    audio_events: list of (start, end, stressed) tuples.
    """
    gestures = []
    for start, end, stressed in audio_events:
        gesture = self.generate(utterance, target=target)
        gesture["start"] = start
        gesture["end"] = end
        gestures.append(gesture)
    return gestures

Cela rend l’alignement temporel explicite et reflète l’objectif de recherche de générer des gestes qui ne sont pas seulement sémantiquement corrects mais aussi prosodiquement cohérents.

Considérations pratiques et limites ouvertes

Travailler avec l’approche AgentHands dans un produit réel implique de prêter attention à plusieurs contraintes que l’article de recherche, comme la plupart des publications académiques, simplifie nécessairement.

Budget de latence. La XR interactive exige une génération de gestes à des cadences interactives. Si le modèle s’exécute sur un nœud serveur puissant, le temps d’aller-retour réseau devient un facteur. S’il s’exécute sur l’appareil, vous disposez d’un budget de puissance et thermique limité. Un pipeline pratique découple donc les types de gestes « rapides » (battements et points simples) des types de gestes « lents » (séquences de manipulation d’objets qui nécessitent plus de contexte), et retombe gracieusement sur une solution de repli lorsque le modèle ne peut pas suivre.

Représentation de la scène. La qualité des gestes spatialement ancrés dépend de la manière dont vous encodez la scène. Une liste plate de boîtes englobantes est un bon début, mais le modèle fonctionnera mieux si la représentation de la scène inclut des informations relationnelles : quels objets sont sur la table, lesquels sont à portée de main, et lesquels sont à l’autre bout de la pièce. Vous devriez concevoir votre fournisseur de scène pour émettre ces relations sous forme de données structurées plutôt que d’attendre que le modèle de gestes les déduise de la géométrie brute.

Retargeting. Un geste généré pour un squelette de main générique ne se transférera pas parfaitement à chaque avatar. Les proportions de la main, la longueur des doigts et la mobilité des épaules affectent toutes l’apparence du mouvement. Vous avez besoin d’une couche de retargeting qui mappe les angles articulaires générés sur le squelette cible, et vous devez valider visuellement que le résultat ne produit pas de torsion non naturelle ou d’auto-intersection.

Évaluation. Mesurer la qualité des gestes reste un problème de recherche ouvert. Des métriques objectives telles que le glissement des pieds, la distance de contact main-objet et l’alignement temporel avec la parole peuvent détecter les erreurs grossières, mais des études utilisateur subjectives sont toujours nécessaires pour déterminer si un geste semble naturel, s’il aide à la compréhension, et s’il est perçu comme correctement ancré. L’article du blog Google Research rapporte des résultats d’évaluation dans cette veine, mais bien sûr ces résultats sont liés à son dispositif expérimental spécifique ; vous devriez reproduire votre propre évaluation pour votre propre avatar, scène et domaine dialogique.

Généralisation. Un modèle entraîné sur un domaine conversationnel ou un style de gestes culturel ne se transférera pas nécessairement à un autre. Les gestes sont culturellement spécifiques, et un style de pointage perçu comme naturel dans un contexte peut ne pas l’être dans un autre. Si votre produit cible différentes langues ou cultures, prévoyez de collecter ou de curer des données qui reflètent cette diversité, et traitez l’approche publiée comme une méthode, pas comme un produit fini.

Il existe aussi un problème d’ambiguïté sémantique qu’aucun modèle de génération ne résout complètement : le même geste physique peut avoir différentes significations, et la même signification peut être exprimée par différents gestes. Le modèle réduit cette ambiguïté en se conditionnant sur l’énoncé, mais il ne peut pas l’éliminer. En tant qu’ingénieur, vous devriez concevoir votre système dialogique pour être résilient aux gestes mal interprétés, par exemple en confirmant explicitement les références spatiales lorsque le contexte de l’utilisateur les rend ambiguës.

Conclusion

AgentHands pointe vers un avenir dans lequel les agents XR ne se contentent pas de parler de manière convaincante, mais bougent aussi de manière convaincante. En générant des gestes de la main interactifs ancrés dans la scène 3D réelle, l’approche remédie à une déficience que les utilisateurs ressentent immédiatement mais ont du mal à articuler : les mains de l’agent participent enfin à la conversation. La contribution de l’article de recherche est de traiter la génération de gestes non pas comme un problème de lecture de fichiers mais comme un problème génératif, conditionné par la scène et interactif, et ce cadrage est exactement le bon pour les contraintes des espaces immersifs.

Pour les développeurs, la voie pratique est maintenant plus claire. Vous avez besoin d’un fournisseur de scène spatiale qui indique à l’agent où sont les choses, d’un modèle de génération de gestes qui consomme à la fois l’énoncé et ce contexte spatial, et d’une couche d’animation qui retargette le mouvement généré sur votre avatar. L’intégration est réalisable aujourd’hui, même sans SDK officiel. Le pipeline de référence présenté ici — une interface Python propre, une représentation de scène, et une séparation claire entre l’intention gestuelle et l’animation de l’avatar — vous permettra de prototyper l’expérience dès maintenant et d’intégrer un modèle appris plus tard.

La prochaine fois que vous mettrez un casque et entrerez en conversation avec un agent, faites attention à ses mains. S’il pointe l’objet réel qu’il décrit, au bon moment, d’une manière qui correspond au rythme de sa parole, vous observez le résultat d’une génération de gestes spatialement ancrés. AgentHands est une étape importante pour faire de ce comportement la norme plutôt que l’exception.