Un Agent Harness est l'infrastructure logicielle entourant un modèle de langage qui lui permet d'effectuer des actions.

L'infrastructure est responsable de :

• Construire le contexte du modèle.
• Communiquer avec le LLM.
• Fournir des outils au LLM.
• Exécuter les appels d'outils demandés.
• Renvoyer les résultats des outils au modèle.
• Gérer les conversations et les sessions.
• Contrôler le cycle de vie de l'exécution.

Le LLM fournit les capacités de raisonnement.

L'infrastructure fournit l'environnement dans lequel ce raisonnement peut être traduit en actions.

Un chatbot traditionnel suit généralement ce modèle :

flowchart LR
    A["Utilisateur"] --> B["Prompt"]
    B --> C["LLM"]
    C --> D["Réponse"]

Un agent de codage IA ajoute un environnement d'exécution :

flowchart TD
    A["Utilisateur"] --> B["Agent Pi"]
    B --> C["LLM"]
    C --> D{"Outil nécessaire ?"}
    D -->|Oui| E["Exécuter l'outil"]
    E --> F["Retourner le résultat"]
    F --> C
    D -->|Non| G["Réponse finale"]

Exemple :

Chatbot : "Voici le code Python qui calcule les dépenses."

Pi : "J'ai créé les fichiers Python, exécuté le programme, lancé les tests et corrigé une erreur."

La différence importante est la capacité d'interagir avec un environnement réel.

Minimalisme :

• Garder le noyau relativement petit.
• Éviter les abstractions inutiles.
• S'appuyer sur les outils existants du système d'exploitation.

Extensibilité :

• Créer des outils personnalisés.
• Construire des extensions.
• Utiliser des compétences réutilisables.
• Connecter des services externes.

Indépendance vis-à-vis du modèle :

• Utiliser différents fournisseurs de LLM.
• Changer de modèle au sein du même environnement.
• Comparer le comportement des modèles.

Transparence :

• Observer les réponses du modèle.
• Inspecter les exécutions d'outils.
• Examiner les modifications.
• Consulter l'historique de session.

Une configuration de base de Pi ne nécessite pas :

• Une base de données vectorielle.
• Un serveur d'orchestration séparé.
• Kubernetes.
• Docker.
• Un framework multi-agents complexe.
• Une application backend personnalisée.

Pour une démonstration de base, un terminal, un LLM pris en charge, et un répertoire local suffisent.

flowchart TB
    USER["Développeur"]

    subgraph PI["Pi Coding Agent"]
        UI["Interface Terminal"]
        CORE["Runtime de l'agent"]
        CONTEXT["Gestionnaire de contexte"]
        SESSION["Gestionnaire de session"]
        TOOLS["Exécution d'outils"]
        EXT["Extensions / Compétences"]
        API["Abstraction API LLM"]
    end

    subgraph MODELS["Fournisseurs LLM"]
        OPENAI["OpenAI"]
        ANTHROPIC["Anthropic"]
        GOOGLE["Google"]
        LOCAL["Modèles locaux"]
    end

    subgraph SYSTEM["Environnement de développement"]
        FILES["Système de fichiers"]
        BASH["Shell"]
        GIT["Git"]
        TESTS["Tests"]
    end

    USER <--> UI
    UI <--> CORE

    CORE <--> CONTEXT
    CORE <--> SESSION
    CORE <--> TOOLS
    CORE <--> API

    EXT --> CORE

    API <--> OPENAI
    API <--> ANTHROPIC
    API <--> GOOGLE
    API <--> LOCAL

    TOOLS <--> FILES
    TOOLS <--> BASH
    TOOLS <--> GIT
    TOOLS <--> TESTS

Il s'agit d'une architecture conceptuelle, montrant les principales responsabilités plutôt que chaque dépendance interne.

Pi est développé comme une collection de paquets TypeScript.

flowchart TD
    USER["Développeur"]
    TUI["pi-tui"]
    CODING["pi-coding-agent"]
    CORE["pi-agent-core"]
    AI["pi-ai"]
    LLM["Fournisseurs LLM"]

    USER <--> TUI
    TUI <--> CODING
    CODING <--> CORE
    CORE <--> AI
    AI <--> LLM

    CODING --> FS["Outils"]
    CODING --> SESSION["Sessions"]
    CODING --> EXT["Extensions"]

La même infrastructure d'agent peut également être utilisée via des interfaces non interactives.

Exemple :

"Crée une application Python qui suit les dépenses."

Pi reçoit cette requête via son interface terminal.

Avant de contacter le LLM, Pi prépare le contexte.

Cela peut inclure :

• Instructions système.
• Requête de l'utilisateur.
• Historique de la conversation active.
• Outils disponibles.
• Instructions de projet depuis AGENTS.md.
• Descriptions des compétences.
• Contenu de fichier pertinent.
• Configuration du modèle.

La branche de session active détermine quels messages historiques sont inclus.

Pi envoie la requête préparée au fournisseur de LLM sélectionné.

Le LLM peut produire :

• Du texte en langage naturel.
• Des appels d'outils structurés.
• Une combinaison des deux.

Exemple de requête d'outil :

Outil : write Fichier : expenses.py Contenu : Code source Python

Le LLM n'écrit pas directement le fichier.

Il demande à Pi d'exécuter l'opération.

Pi reçoit l'appel d'outil demandé.

L'exécuteur d'outils effectue l'action.

Exemples :

• Lire un fichier.
• Écrire un fichier.
• Modifier du code.
• Exécuter une commande shell.

Pi capture ensuite le résultat.

La sortie est renvoyée au runtime de l'agent.

Exemple :

Outil : bash Commande : python expenses.py

Résultat : Traceback: NameError …

Le résultat devient une partie du contexte disponible pour le LLM.

Le LLM peut décider de :

• Appeler un autre outil.
• Modifier le code.
• Lancer des tests supplémentaires.
• Fournir une réponse finale.

Pi répète le processus tant qu'une exécution supplémentaire est requise.

Cette interaction est le fondement du comportement agentique.

Trois responsabilités sont séparées :

1. LLM : Génère le raisonnement et propose des actions.
2. Agent Harness : Coordonne l'exécution et gère le contexte.
3. Outils : Effectuent des opérations dans l'environnement.

Cette architecture est également fondamentale pour de nombreuses autres implémentations d'agents IA.

Lire le contenu des fichiers.

Exemple de prompt :

"Lis app.py et explique sa structure."

Créer ou écraser des fichiers.

Exemple de prompt :

"Crée un programme Python qui affiche Hello TechHive."

Modifier des fichiers existants.

Exemple de prompt :

"Modifie le programme pour accepter un nom d'utilisateur."

Exécuter des commandes shell.

Exemple de prompt :

"Exécute le programme et affiche le résultat."

flowchart TD
    A["Utilisateur : Corrige le bug"]
    B["Le LLM analyse la requête"]
    C["read : Inspecter le code"]
    D["edit : Corriger le code"]
    E["bash : Lancer les tests"]
    F{"Les tests passent ?"}
    G["Réponse finale"]

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F -->|Non| B
    F -->|Oui| G

Des outils intégrés et des extensions supplémentaires peuvent être disponibles selon la version et la configuration.

Le contexte est l'information fournie au LLM pour une requête de modèle.

Il peut inclure :

• La requête actuelle de l'utilisateur.
• L'historique de la conversation.
• Les résultats des outils.
• Les instructions système.
• Les instructions de projet.
• Les descriptions des compétences.
• Le contenu des fichiers référencés.

Pi ne charge pas automatiquement chaque fichier d'un dépôt dans le contexte du LLM.

Il sélectionne et assemble le contexte en fonction de la session et des ressources configurées.

AGENTS.md est un fichier d'instructions de projet.

Exemple :

# Instructions de projet

Ce projet est destiné à un atelier sur les agents de codage.

Directives :
- Utiliser Python.
- Préférer la bibliothèque standard.
- Garder le code simple.
- Écrire des fonctions lisibles.
- Ajouter des tests pour les nouvelles fonctionnalités.
- Expliquer les changements majeurs.

Ces instructions aident à guider le comportement de l'agent au sein du projet.

Pi maintient des sessions de conversation.

Les sessions peuvent inclure :

• Les messages de l'utilisateur.
• Les messages de l'assistant.
• Les appels d'outils.
• Les résultats des outils.
• Les changements de modèle.
• Les événements de compactage de contexte.

Les sessions persistantes utilisent des fichiers JSONL.

Pi prend en charge une structure de conversation basée sur une arborescence.

flowchart TD
    A["Démarrer la session"]
    B["Créer l'application"]
    C["Ajouter le stockage de données"]

    D["Approche CSV"]
    E["Approche SQLite"]

    F["Tester CSV"]
    G["Tester SQLite"]

    A --> B
    B --> C
    C --> D
    C --> E
    D --> F
    E --> G

Les branches permettent d'explorer des approches alternatives à partir d'états de conversation antérieurs.

Les longues conversations peuvent dépasser la fenêtre de contexte d'un modèle.

Pi peut résumer un contexte plus ancien pour réduire la quantité d'informations envoyées dans les futures requêtes de modèle.

Commande :

/compact

Le compactage aide à gérer la taille du contexte mais peut perdre certains détails des messages plus anciens.

Les entrées de session originales peuvent rester dans l'historique de session stocké.

flowchart TD
    USER["Développeur"]
    PI["Agent Pi"]
    API["Interface de modèle unifiée"]

    USER --> PI
    PI --> API

    API --> A["OpenAI"]
    API --> B["Anthropic"]
    API --> C["Google"]
    API --> D["Modèle local"]

Avantages :

• Flexibilité.
• Comparaison de modèles.
• Choix du fournisseur.
• Optimisation des coûts.
• Expérimentation.

Les capacités et la compatibilité des modèles peuvent varier.

Instructions spécifiques au projet.

Prompts réutilisables pour des activités récurrentes.

Exemples :

• Revue de code.
• Documentation.
• Génération de tests.
• Refactorisation.

Instructions réutilisables et ressources de support pour des flux de travail spécialisés.

Exemples :

• Flux de travail de test Python.
• Flux de travail de déploiement.
• Génération de documentation.
• Développement d'API.

Personnalisation basée sur TypeScript.

Les extensions peuvent :

• Définir des outils personnalisés.
• Enregistrer des commandes.
• Réagir aux événements du cycle de vie.
• Intégrer des services externes.
• Personnaliser le comportement interactif.

MCP signifie Model Context Protocol (Protocole de contexte de modèle).

Il fournit un moyen standardisé pour les applications d'accéder à des outils et ressources externes.

Les versions modernes de Pi fournissent un support MCP intégré.

Exemples d'intégrations :

• GitHub.
• Bases de données.
• Applications internes.
• Services distants.

Lancer l'interface terminal.

pi

Exécuter un prompt et imprimer sa réponse.

pi -p "Explique les décorateurs Python"

Diffuser des événements d'agent structurés.

pi --mode json -p "Explique ce projet"

Contrôler Pi en utilisant des messages JSONL via l'entrée et la sortie standard.

Intégrer les capacités de l'agent Pi dans des applications TypeScript.

flowchart TD
    CORE["Runtime de l'agent Pi"]

    CORE --> A["TUI interactif"]
    CORE --> B["Impression / JSON"]
    CORE --> C["RPC"]
    CORE --> D["SDK TypeScript"]

    A --> E["Développeur"]
    B --> F["Scripts d'automatisation"]
    C --> G["Application externe"]
    D --> H["Application d'agent personnalisée"]

macOS / Linux :

curl -fsSL https://pi.dev/install.sh | sh

Windows PowerShell :

irm https://pi.dev/install.ps1 | iex

Alternative utilisant npm :

npm install -g --ignore-scripts @earendil-works/pi-coding-agent

L'installation npm nécessite Node.js 22.19 ou plus récent.

Dans Pi :

/login

Sélectionnez un fournisseur pris en charge et authentifiez-vous.

Ensuite :

/model

Sélectionnez le modèle que vous souhaitez utiliser.

Prompt :

Inspecte le répertoire actuel.

Explique quels fichiers sont présents.

Ne modifie rien.

Concept : Exploration du système de fichiers et opérations de lecture.

Prompt :

Crée un simple suivi de dépenses Python.

Exigences :
- Ajouter une dépense.
- Lister les dépenses.
- Calculer le total des dépenses.
- Stocker les dépenses dans un fichier CSV.
- Utiliser uniquement la bibliothèque standard Python.

Garde l'implémentation simple.

Concept : Génération de code et création de fichiers.

Prompt :

Exécute l'application.

Crée trois exemples de dépenses.

Vérifie que le total est calculé correctement.

Concept : Exécution shell et observation des résultats.

Prompt :

Crée des tests unitaires en utilisant unittest de Python.

Teste la création de dépenses et le calcul du total.

Exécute les tests et corrige les erreurs.

Concept : Tests autonomes et correction itérative.

Prompt :

Ajoute une fonctionnalité pour regrouper les dépenses par catégorie.

Affiche le total pour chaque catégorie.

Met à jour les tests et exécute-les.

Concept : Modification de code et rétention de contexte.

Commandes :

/session /tree /model

Concept : Historique de session, branchement et changement de modèle.

Infrastructure d'agent de codage minimale et extensible.

Points forts :

• Personnalisation.
• Plusieurs fournisseurs de LLM.
• Exécution d'outils.
• Gestion de session.
• Extensibilité.

Agent de codage avec un ensemble intégré d'outils de développement et de flux de travail.

Agent de codage conçu pour travailler avec des bases de code, des commandes de terminal et des flux de travail de développement.

Frameworks pour développer des applications LLM personnalisées et des flux de travail agentiques.

Pi est principalement une infrastructure d'agent prête à l'emploi et extensible, plutôt qu'un framework de graphe de flux de travail généraliste.