Pourquoi un outil run() unique avec des commandes Unix surpasse l'appel de fonctions pour les agents IA

Un développeur avec deux ans d'expérience dans la création d'agents IA—d'abord en tant que responsable backend chez Manus, puis sur les projets open-source Pinix et agent-clip—a conclu qu'un outil unique run(command="...") avec des commandes de style Unix fonctionne mieux que les approches traditionnelles d'appels de fonctions.

La Convergence Unix-LLM

L'idée centrale est que la décision de conception vieille de 50 ans d'Unix—tout est un flux de texte—s'aligne parfaitement avec la nature textuelle des LLM. Les programmes Unix communiquent via des tuyaux de texte, utilisent --help pour s'auto-décrire, signalent le succès/l'échec avec des codes de sortie, et communiquent les erreurs via stderr. Les LLM comprennent de même uniquement des jetons de texte. Cela fait de l'interface textuelle d'Unix un ajustement naturel pour les LLM, qui fonctionnent essentiellement comme des opérateurs de terminal avec une exposition étendue aux commandes shell dans leurs données d'entraînement.

L'Approche à Outil Unique

La plupart des frameworks d'agents fournissent aux LLM un catalogue d'outils indépendants comme [search_web, read_file, write_file, run_code, send_email, ...], nécessitant que le LLM prenne des décisions de sélection d'outil avant chaque appel. À mesure que plus d'outils sont ajoutés, la précision de sélection diminue car la charge cognitive passe de "qu'est-ce que je dois accomplir ?" à "quel outil ?"

L'approche alternative utilise un seul outil run(command="...") qui expose toutes les capacités sous forme de commandes CLI :

run(command="cat notes.md")
run(command="cat log.txt | grep ERROR | wc -l")
run(command="see screenshot.png")
run(command="memory search 'deployment issue'")
run(command="clip sandbox bash 'python3 analyze.py'")

La sélection de commande devient une composition de chaînes au sein d'un espace de noms unifié plutôt qu'une commutation de contexte entre des API sans rapport.

Pourquoi les Commandes CLI Fonctionnent Mieux

Les commandes CLI sont le modèle d'utilisation d'outils le plus dense dans les données d'entraînement des LLM, apparaissant dans des milliards de lignes sur GitHub (instructions d'installation README, scripts de build CI/CD, solutions Stack Overflow). Le développeur note : "Je n'ai pas besoin d'apprendre au LLM comment utiliser la CLI—il le sait déjà."

Comparez les approches pour la même tâche :

Tâche : Lire un fichier journal, compter les lignes d'erreur

Approche par appel de fonction (3 appels d'outil) :
1. read_file(path="/var/log/app.log") → retourne le fichier entier
2. search_text(text=, pattern="ERROR") → retourne les lignes correspondantes
3. count_lines(text=) → retourne le nombre

Approche CLI (1 appel d'outil) :
run(command="cat /var/log/app.log | grep ERROR | wc -l") → "42"

Un appel remplace trois parce que les tuyaux Unix supportent nativement la composition. Le développeur souligne qu'il ne s'agit pas d'une optimisation spéciale mais d'exploiter la conception existante d'Unix.