Ma Stack Pi Coding Agent

L’émergence des assistants de développement pilotés par des LLMs (Large Language Models) a profondément transformé notre façon de concevoir, prototyper et maintenir du code. Pourtant, la majorité des solutions du marché (extensions d’IDEs, applications propriétaires en sandbox fermée ou simples clients CLI) imposent des compromis majeurs : contextes éphémères qui s’évaporent à la fin d’une session, exécution séquentielle bloquante, incapacité à interagir avec le monde extérieur de manière asynchrone, et absence de contrôle sur la sécurité des commandes exécutées.

Pour dépasser ces limites, j’ai construit un écosystème sur-mesure articulé autour de Pi Coding Agent (@earendil-works/pi-coding-agent), un agent de développement modulaire et extensible écrit en TypeScript.

Cette stack ne se contente pas d’exécuter de simples commandes bash ou de modifier des fichiers texte. Elle intègre un moteur de mémoire persistante SQLite à double modèle, un orchestrateur de sous-agents (pi-subagents) capable d’exécuter jusqu’à 10 workers en tâche de fond avec isolation worktree et profils spécialisés (Explore, Plan), un bridge Discord bidirectionnel pour le pilotage distant sur mobile, une passerelle MCP avancée connectée à mon infrastructure Zero Trust, une sécurisation proactive des commandes système, et plusieurs providers (OpenAI Codex, Antigravity et recherche Web) avec raisonnement (thinking models) et génération d’images.

Voici le deep dive technique complet de cette architecture.

Vue d’ensemble de l’Architecture

L’architecture globale de ma stack Pi s’organise en couches interconnectées garantissant une séparation stricte entre le runtime d’orchestration, les extensions métier, les moteurs de stockage et les interfaces externes :

flowchart TB
    subgraph UI["Interfaces Utilisateur & Contrôle Distant"]
        TUI["Pi TUI (Terminal Interactif)"]
        Discord["Discord Mobile / Desktop<br>Boutons Interactifs & Webhooks"]
    end

    subgraph Runtime["Cœur Pi Coding Agent (TypeScript / Node.js)"]
        Core["Orchestrateur Pi & State Machine"]
        ExtLoader["Loader d'Extensions & Packages"]
        ToolManager["Tool Registry & Guardrails"]
    end

    subgraph LLMProviders["Couche LLMs & Providers"]
        Antigravity["pi-antigravity (OAuth Google Cloud Code)<br>Gemini 3.7 / 3.8 Flash Thinking"]
        Quotas["pi-quotas (Rate Limits & Token Trackers)"]
    end

    subgraph Parallelism["Exécution Parallèle & Multiplexage"]
        Subagents["pi-subagents (Pi 1.4.0 & RPC pi.events)<br>Délégation imbriquée, Explore, Plan & Worktree"]
        PTYManager["terminal manager (Persistent PTY)<br>Sessions d'arrière-plan & Monitor regex"]
    end

    subgraph MemoryLayer["Mémoire Persistante Long-Terme"]
        SQLiteDB[("observational-memory.sqlite<br>Ledger de branches & Compaction")]
        Observer["Observer Model (Headless Pi)<br>Extraction d'observations atomiques"]
        Consolidator["Consolidator Model<br>Consolidation thématique long terme"]
    end

    subgraph SecurityExt["Sécurité & Outils Locaux"]
        BashGuard["bash-guard (Interception L7 & Confirmation)"]
        MoveTool["move-tool (AST Relocation & Rollback)"]
        TodoTool["pi-todotools (State machine par phases)"]
        SearchTools["pi-web-search & Gemini URL Context"]
    end

    subgraph MCPLayer["Passerelle MCP Native (mcp.json)"]
        MCPEngine["Client MCP Natif & Outil +codemode"]
        CFAPI["Cloudflare API (deferred) & Browser (direct)"]
        Context7["Context7 (Docs temps réel)"]
        GrepApp["Grep.app (GitHub Code Search)"]
        GitHubMCP["GitHub Copilot MCP (Dynamic Token)"]
        LugoMCP["Lugo (Lua 5.4 LSP & MCP)"]
    end

    UI <--> Runtime
    Runtime --> LLMProviders
    Runtime --> Parallelism
    Runtime --> MemoryLayer
    Runtime --> SecurityExt
    Runtime --> MCPLayer
    Discord <-->|"pi-bridge (HTTPS / Webhooks)"| Runtime

1. Le Moteur de Modèles : pi-antigravity & pi-quotas

Le cœur d’un agent de développement réside dans la pertinence de ses modèles de langage et la fiabilité de sa couche de communication API.

pi-antigravity : L’intégration Google Cloud Code

Plutôt que de dépendre d’un seul endpoint, j’utilise plusieurs providers selon la tâche. pi-antigravity implémente l’authentification OAuth directe avec les services Google Antigravity / Cloud Code, tandis que mon profil local utilise actuellement OpenAI Codex comme modèle par défaut. L’environnement tourne désormais sur Pi 1.4.0 et gère ses dépendances et sous-agents de manière centralisée. Les préférences privées restent séparées de la configuration partageable.

{
  "lastChangelogVersion": "1.4.0",
  "theme": "dark",
  "defaultProvider": "openai-codex",
  "defaultModel": "gpt-6-luna",
  "enableInstallTelemetry": false,
  "enableAnalytics": false,
  "packages": [
    "git:github.com/FRFlo/pi-web-search",
    "git:github.com/code-yeongyu/pi-apply-patch",
    "git:github.com/FRFlo/pi-todotools",
    "git:github.com/FRFlo/pi-quotas",
    "npm:pi-antigravity",
    "npm:pi-lsp",
    "npm:@tintinweb/pi-subagents"
  ],
  "observational-memory": {
    "backend": "sqlite",
    "models": {
      "observer": {
        "provider": "antigravity",
        "id": "gemini-3.7-flash"
      },
      "consolidator": {
        "provider": "antigravity",
        "id": "gemini-3.7-flash"
      }
    }
  },
  "terminal": {
    "notify": "next-turn"
  },
  "hideThinkingBlock": true,
  "defaultTools": ["+codemode"]
}

Cette intégration offre plusieurs avantages clés :

1. Accès natif aux Thinking Models : Support transparent des modèles Gemini disponibles dans le catalogue Antigravity, avec configuration du niveau de réflexion (thinking level : off, low, medium, high, max).
2. Persistance automatique du modèle choisi : Grâce à l’écoute de l’événement model_select dans preferences-loader.ts, tout changement de modèle ou de provider effectué en cours de session est immédiatement persisté dans preferences.json, garantissant une continuité parfaite entre sessions de travail.
3. Génération d’images intégrée (generate_image) : Possibilité pour l’agent de concevoir des maquettes graphiques, assets ou schémas directement via les modèles Imagen / Gemini sans quitter le cycle de dev.
4. Gestion automatique des jetons OAuth : Rafraîchissement transparent des credentials sans nécessiter d’injections manuelles de clés d’API dans l’environnement shell.

pi-quotas : Surveillance temps réel des limites de consommation

Développé sur-mesure pour ma stack, le package pi-quotas se greffe aux hooks du cycle de vie de Pi pour afficher les quotas Antigravity réels, les compteurs de tokens et le délai avant réinitialisation. Il permet d’anticiper les dépassements de seuil et d’éviter les interruptions brutales lors de sessions de refactoring intensives.

2. Mémoire Persistante Long-Terme : observational-memory

L’un des problèmes majeurs des agents IA classiques est l’amnésie de contexte : au fur et à mesure que la conversation s’allonge, le context window s’engorge, forçant une troncation destructrice ou un résumé naïf qui élimine les décisions d’architecture critiques.

Pour résoudre ce problème de manière déterministe, ma stack intègre l’extension Observational Memory, une architecture de mémoire hiérarchisée basée sur SQLite.

flowchart LR
    A["Chunks de conversation<br/><i>Découpage par tokens fixes</i>"] --> B["Observers parallèles<br/><i>Instances pi headless</i>"]
    B --> C["Observations atomiques<br/><i>{timestamp, contenu, contexte}</i>"]
    C --> D["Master Ledger SQLite<br/><i>observational-memory.sqlite</i>"]
    D --> E["Compaction Déterministe<br/><i>Sans appel LLM (zero hallucination)</i>"]
    D --> F["Consolidator Model<br/><i>gemini-3.7-flash dédié</i>"]
    F --> G["Stockage SQLite durable<br/><i>Historique thématique & scopes session</i>"]

Fonctionnement du double modèle (Observer / Consolidator)

1. L’Observer (Observateur Asynchrone) : En tâche de fond, des sous-processus légers analysent les blocs récents de la conversation. Ils en extraisent des observations atomiques (faits, préférences de style, décisions de conception, corrections d’erreurs). Leurs sessions internes sont automatiquement masquées de l’arborescence pour ne pas polluer l’historique utilisateur.
2. Le Master Ledger SQLite : Toutes les observations et snapshots d’état sont inscrits directement dans une base SQLite unifiée (observational-memory.sqlite). Cette structure est compatible avec l’arbre d’état de Pi (/tree), garantissant que si une session bifurque ou revient en arrière, la mémoire reste fidèle à la branche active.
3. La Compaction Déterministe : Contrairement aux approches conventionnelles où un LLM résume le contexte (avec le risque d’inventer ou de perdre des détails), la compaction de Pi compile les observations vérifiées directement dans le bloc de contexte système.
4. Le Consolidator et stockage durable SQLite : Périodiquement, le modèle consolidateur regroupe et consolide les observations plus anciennes directement dans la base SQLite locale (observational-memory.sqlite). Fini les fichiers Markdown intermédiaires dispersés sur le disque : les archives thématiques et l’historique de session sont conservés durablement dans SQLite, garantissant un cloisonnement strict par projet et session tout en permettant le clonage instantané du scope mémoire lors d’un fork de session. Le répertoire .memory/ ne sert désormais que de bac à sable éphémère pour les workers.

3. Sous-Agents & Orchestration Parallèle : pi-subagents

Les tâches d’ingénierie logicielle exigent souvent de mener de front plusieurs chantiers : explorer une arborescence inconnue, auditer des logs de build, exécuter des tests de non-régression et concevoir une architecture.

La stack s’appuie désormais sur pi-subagents (package @tintinweb/pi-subagents@0.22.0, fork FRFlo/pi-subagents), déployé sur Pi 1.4.0 et substituant l’ancien sous-module interactive-subagents. Ce composant apporte une orchestration complète de sous-agents asynchrones inspirée de Claude Code, pilotable déclarativement via subagents.json.

╭─ Subagents ────────────────────────── 3 running ─╮
│ 00:12  Explore   active · grep 2m (worktree)     │
│ 00:18  Plan      active · codex 4m               │
│ 00:25  Reviewer  waiting (RPC delegate)          │
╰──────────────────────────────────────────────────╯

Orchestration déclarative (subagents.json)

L’extension est configurée de manière centralisée pour optimiser la concurrence et le confort visuel :

• Concurrence & exécution d’arrière-plan : maxConcurrent: 10 avec backgroundByDefault: true. L’agent principal ne reste jamais bloqué pendant qu’un sous-agent explore ou compile.
• Isolation par Git Worktree (worktreeIsolation: true) : Chaque sous-agent travaillant sur du code opère dans un arbre de travail Git dédié. Plusieurs agents peuvent modifier, tester ou compiler des branches distinctes sans collision sur le répertoire de travail principal.
• Observabilité TUI (fleetView: true, widgetMode: "all") : Affichage d’une vue d’ensemble de la flotte et d’un widget réactif dans le terminal récapitulant l’état, la durée et le modèle de chaque agent actif.
• Imbrication & jointure intelligente : Support de sous-agents récursifs jusqu’à 2 niveaux de profondeur (maxSubagentDepth: 2) et réintégration automatique des conclusions par jointure contextuelle (defaultJoinMode: "smart").

Profils d’agents globaux spécialisés (agents/)

Plutôt que d’instancier des agents génériques avec l’ensemble des outils, la stack définit des profils d’agents spécialisés dans agents/ avec remplacement strict du prompt système (prompt_mode: replace) ou mode append (prompt_mode: append), cloisonnement d’outils par allowlist et autorisation explicite de la délégation imbriquée (allowed_subagents: all) :

1. Explore (agents/Explore.md) : Spécialiste de la navigation de codebase et de la recherche de symboles en lecture seule (tools: read, bash, grep, find, ls). Le prompt interdit formellement toute modification de fichier, redirection ou écriture sur disque, et Bash est strictement bridé aux commandes d’inspection (git status, git diff, cat, etc.). Il est propulsé par antigravity/gemini-3.8-flash pour une rapidité maximale à coût maîtrisé et autorise la subdélégation (allowed_subagents: all).
2. Plan (agents/Plan.md) : Architecte logiciel dédié à l’élaboration de plans d’implémentation ordonnés sans altération de code (tools: read, bash, grep, find, ls). Propulsé par openai-codex/gpt-6.1-sol, il explore l’existant, analyse les arbitrages techniques, planifie les étapes d’exécution, liste les fichiers critiques d’implémentation et autorise la subdélégation (allowed_subagents: all).
3. general-purpose (agents/general-purpose.md) : Profil d’agent généraliste complet (tools: all, allowed_subagents: all, prompt_mode: append) capable de prendre en charge des workflows entiers tout en déléguant des sous-tâches indépendantes en cascade.
4. supervisor-planner (agents/supervisor-planner.md) : Agent de planification sans outils (tools: none), chargé de convertir une requête utilisateur en items Todo concis assortis de critères d’acceptation privés.
5. supervisor-reviewer (agents/supervisor-reviewer.md) : Agent de revue en lecture seule (tools: read, grep, find, ls) qui vérifie de manière indépendante les checkpoints Todo terminés par rapport à leurs critères privés et à la demande d’origine.

Directives d’orchestration & revue indépendante (APPEND_SYSTEM.md)

Pour encadrer l’autonomie des agents et préserver la rigueur des revues, des directives globales sont injectées en fin de prompt système :

• Décomposition et exploration systématique : Pour les demandes larges ou très larges, l’agent délègue l’exploration et la décomposition à des sous-agents en tâche de fond. Le travail d’implémentation est également subdélégué lorsqu’il peut être partitionné en sous-tâches indépendantes et sans conflit.
• Critique et audit en contexte vierge : Dès qu’une tâche consiste à contredire, auditer ou relire un travail existant, l’évaluation est impérativement déléguée à un sous-agent doté d’un contexte vierge. L’agent lui transmet le code et les critères de revue, mais omet délibérément ses propres conclusions et son raisonnement privé pour garantir une analyse totalement indépendante.
• Planification proportionnée & questions ciblées : Les tâches complexes sont obligatoirement planifiées avant exécution. En cas d’ambiguïté substantielle susceptible de changer la trajectoire du travail, l’outil de questionnement clarifie le besoin sans interrompre l’utilisateur pour des micro-détails sans impact.

Délégation événementielle RPC (pi.events)

Le superviseur (extensions/supervisor/index.ts) ne charge plus directement de classes internes. Il dialogue avec pi-subagents via le bus d’événements RPC de Pi :

• Cycle de vie RPC : Déléguant le spawn (subagents:rpc:spawn), la capture des résultats (subagents:completed, subagents:failed) et la libération (subagents:rpc:consume, subagents:rpc:stop).
• Masquage des sessions techniques (persistSession: false) : Les sessions des agents de planification et de revue sont automatiquement exclues de la persistance pour préserver un historique utilisateur propre et lisible.
• Sécurité et périmètre : Les instructions du relecteur limitent strictement l’inspection au dépôt de travail actif, traitant les affirmations des workers comme non vérifiées tant qu’une preuve factuelle n’a pas été constatée.

4. Supervision Distante & Bridge Discord Mobile

Pour garder le contrôle sur des tâches d’automatisation longues lorsque je ne suis pas devant mon poste de travail, la stack intègre un bridge Discord bidirectionnel temps réel.

sequenceDiagram
    participant Pi as Pi Coding Agent
    participant Bridge as pi-bridge (API)
    participant Discord as Discord Client (Mobile/Web)

    Pi->>Bridge: POST /ask (Question + Choix + Recent Turn)
    Bridge->>Discord: Message Embed + Boutons ActionRow
    Note over Discord: L'utilisateur clique sur une option<br/>ou tape une réponse libre
    Discord->>Bridge: Interaction Webhook (Component Click / Modal)
    Bridge-->>Pi: Réponse HTTP résolue (Option choisie / Texte)
    Pi->>Pi: Reprise immédiate du flux de travail

L’extension ask-user-question et son TUI réactif

Lorsqu’un choix d’architecture ou une confirmation est requis, l’outil ask_user_question s’adapte dynamiquement à l’environnement :

1. En mode TUI interactif : Affichage d’un menu déroulant ANSI navigable au clavier (touches fléchées, barre d’espace pour multi-sélection, champ de saisie libre).
2. Synchronisation Discord instantanée : En parallèle, le payload est transmis au service pi-bridge. Une interface riche avec des boutons interactifs apparaît sur Discord. Que je réponde depuis mon terminal ou depuis mon smartphone, l’interaction est résolue instantanément.
3. Mode RPC headless (hermes-rpc) : En cas de pilotage par un orchestrateur externe comme Hermes Agent via son interface JSONL RPC, les dialogues basculent sur des primitives sérialisables (hermesSelect, hermesInput), permettant une sélection programmatique ou déléguée sans exiger de TUI interactif.
4. Questions persistantes et rapports proactifs : ask_user_question persiste et restaure automatiquement les questions en attente en cas de rechargement ou d’interruption de session, prévenant toute perte d’interaction bloquante. Une question peut rester ouverte jusqu’à une réponse depuis le TUI, Discord ou l’interface RPC, tandis que send_discord_message transmet les fins de build, alertes de régression et synthèses de déploiement en Markdown riche.

5. Terminal Persistant & Sécurité Active : terminal & bash-guard

La manipulation du système hôte par un agent IA comporte des risques majeurs : commandes destructrices accidentelles, processus d’arrière-plan fantômes et surcharge mémoire.

Terminal persistant PTY et pattern monitor

L’extension terminal dote Pi d’un gestionnaire de sessions PTY (pseudo-terminal) complètes :

• Injection dynamique du contexte terminal : L’environnement d’exécution injecte dynamiquement l’état courant du terminal (dossier de travail actif, commandes récentes, statut d’exécution) dans le prompt de l’agent sans surcharger inutilement la fenêtre de contexte.
• Sessions en tâche de fond : Lancement de serveurs dev, conteneurs ou builds sans bloquer le REPL.
• Souscription d’événements (monitor) : Au lieu de scruter passivement un log, l’agent s’abonne à des expressions régulières spécifiques (ex: READY, Compiled successfully, ERROR). L’agent est notifié dès que la condition est satisfaite.
• Pilotage de REPLs interactifs : Envoi de frappes de touches et de signaux (ctrl+c, bash_input, bash_resize).

bash-guard : L’intercepteur de sécurité L7

Pour prémunir le système contre toute fausse manipulation, chaque commande shell est soumise au filtre de bash-guard :

• Analyse syntaxique préventive : Détection des motifs à risque (rm -rf /, mkfs, écrasement de disques, commandes avec élévation de privilèges imprévue).
• Floor de confirmation adaptatif : En cas de doute, la commande est mise en pause et nécessite une validation explicite de l’utilisateur (via le TUI, le bridge Discord ou le sélecteur RPC headless).

6. La Passerelle MCP Native (mcp.json) & Outil +codemode

Le standard MCP (Model Context Protocol) permet d’étendre les capacités de l’agent vers des services tiers. Dans les versions antérieures de la stack, cette connexion passait par un adaptateur intermédiaire (pi-mcp-adapter). La configuration s’appuie désormais directement sur le client MCP natif de Pi, déclaré de façon centralisée dans mcp.json et couplé à l’outil d’exécution dynamique +codemode activé dans settings.json.

Cette migration vers le moteur natif apporte plusieurs gains architecturaux majeurs :

• Gestion fine de l’exposition (exposure) : Les serveurs denses comme cloudflare-api (qui exposent plusieurs dizaines d’outils) sont configurés en mode différé (exposure: "deferred"). Leurs outils ne s’injectent pas en masse dans le prompt système pour saturer la fenêtre de contexte, mais sont résolus dynamiquement à la demande via une recherche d’outils. À l’inverse, les outils d’extraction web (cloudflare-browser) sont exposés immédiatement (exposure: "direct").
• Authentification dynamique sécurisée : Les jetons d’accès éphémères (notamment pour l’API GitHub Copilot) sont résolus à la volée par interpolation de commande shell (!echo Bearer $(gh auth token)), garantissant l’absence de secrets statiques sur le disque.
• Intégration d’outils locaux zéro-allocation : Le serveur MCP local de Lugo (~/.pi/agent/bin/lugo-mcp.exe), compilé en binaire autonome Go, s’exécute directement sur l’arborescence de travail.

{
  "mcpServers": {
    "context7": {
      "url": "https://mcp.context7.com/mcp",
      "headers": {
        "CONTEXT7_API_KEY": "${CONTEXT7_API_KEY}"
      }
    },
    "grep_app": {
      "url": "https://mcp.grep.app"
    },
    "cloudflare-api": {
      "url": "https://mcp.cloudflare.com/mcp",
      "exposure": "deferred"
    },
    "cloudflare-browser": {
      "url": "https://browser.mcp.cloudflare.com/mcp",
      "exposure": "direct"
    },
    "github": {
      "url": "https://api.githubcopilot.com/mcp",
      "headers": {
        "Authorization": "!echo Bearer $(gh auth token)"
      }
    },
    "svelte": {
      "command": "bunx",
      "args": ["-y", "@sveltejs/mcp"]
    },
    "gitnexus": {
      "command": "bunx",
      "args": ["-y", "gitnexus", "mcp"]
    },
    "lugo": {
      "command": "~/.pi/agent/bin/lugo-mcp.exe",
      "args": ["."],
      "cwd": "."
    },
    "chrome-devtools": {
      "command": "bunx",
      "args": ["-y", "chrome-devtools-mcp@latest"],
      "enabled": false
    }
  }
}

1. cloudflare-browser : Accès Web Visuel & Scraping Headless (Top Priorité)

C’est l’un des MCPs les plus cruciaux de la stack. Contrairement à un simple curl ou fetch textuel incapable d’exécuter du JavaScript, cloudflare-browser pilote une instance Chromium distante managée sur l’Edge de Cloudflare :

• Rendu complet de SPAs & pages dynamiques : Conversion instantanée de pages web riches en Markdown propre (get_url_markdown) ou capture d’instantanés DOM (get_url_html_content).
• Extraction intelligente structurée (get_url_json) : Extraction directe de schémas JSON typés à partir d’une page web via des invites de langage naturel.
• Crawls asynchrones (start_crawl / get_crawl_result) : Exploration récursive de documentations ou de sites entiers en tâche de fond.

2. context7 : La documentation officielle toujours à jour

Les connaissances natives des LLMs s’arrêtent à leur date de coupure d’entraînement (cutoff date) et souffrent d’hallucinations sur les versions majeures récentes de frameworks. context7 comble ce fossé :

• Résolution précise de librairies (context7_resolve-library-id) : Identification exacte du package et de sa version.
• Requêtage ciblé par concept (context7_query-docs) : Récupération d’extraits officiels concis, d’APIs actualisées et d’exemples de code officiels directement injectés dans le contexte.

3. grep_app : L’exploration de code réel sur GitHub

La documentation ne montre souvent que des exemples simplifiés (hello world). grep_app permet à l’agent d’inspecter l’usage d’une bibliothèque en conditions réelles de production :

• Recherche de motifs de code littéraux et regex (grep_app_searchGitHub) parmi plus d’un million de dépôts GitHub publics.
• Validation d’idiomes et de patterns : Vérification de signatures de fonctions, gestion d’erreurs réelles, configurations TypeScript avancées et intégrations entre bibliothèques tierces.

4. Les MCPs d’Infrastructure & Écosystème

• cloudflare-api : Recherche différée dans la spécification OpenAPI et exécution directe d’appels API pour orchestrer Workers, D1, KV, R2, DNS et règles de sécurité.
• lugo : Serveur MCP natif pour Lua 5.4 (~/.pi/agent/bin/lugo-mcp.exe) issu du moteur haute performance zéro-allocation développé sur-mesure (FRFlo/lugo), fournissant analyse syntaxique et capacités AST avancées pour les scripts FiveM et Lua.
• chrome-devtools : Intégration Chrome DevTools MCP (chrome-devtools-mcp@latest) pour l’inspection de pages web, manipulation du DOM et debugging frontend.
• github : Intégration spécialisée pour l’accès aux APIs GitHub Copilot avec jeton dynamique résolu à la volée (!echo Bearer $(gh auth token)).
• Vie privée & désactivation télémétrique : Toute collecte analytique externe a été bannie (enableInstallTelemetry: false, enableAnalytics: false), et l’extension @posthog/pi a été définitivement retirée afin de garantir la stricte confidentialité des sessions de code et du raisonnement de l’agent.

Exécution Programmatique d’Outils : +codemode

Pour optimiser les performances et limiter les tokens consommés lors d’interactions complexes, la stack active nativement l’outil +codemode dans defaultTools. Au lieu d’enchaîner des allers-retours de prompts successifs pour filtrer ou agréger des données issues d’outils MCP, l’agent peut rédiger et exécuter du code TypeScript dans un bac à sable isolé. Ce code interroge directement les outils MCP nécessaires en local, boucle ou filtre les résultats, et ne renvoie que la synthèse pertinente au modèle principal.

7. Boîte à Outils Spécialisée : Refactoring, Tâches & Contexte

En complément des extensions majeures, la stack intègre plusieurs modules spécialisés :

8. Système de Compétences Spécialisées (Skills)

Les Skills permettent de charger à la demande des ensembles de règles expertes et de directives méthodologiques selon le contexte du projet :

• Architecture Cloudflare : cloudflare, wrangler, durable-objects, agents-sdk, sandbox-sdk, cloudflare-one.
• Design Engineering & UI/UX : impeccable (audit ergonomique et typographique), make-interfaces-feel-better (micro-interactions, spring physics, polish d’interface), responsive-craft.
• Règles de Qualité de Code : karpathy-guidelines (réduction des sur-complexifications LLM, modifications chirurgicales et validation par critères mesurables).
• Performance & Debugging : web-perf (Core Web Vitals), web-debug (inspection Playwright live du DOM et réseau).

Workflow Quotidien & Bénéfices

En combinant l’ensemble de ces briques, le cycle de développement quotidien atteint un niveau d’efficacité inédit :

1. Initialisation de mission : Lancement d’une session Pi sur un dépôt de code. Les préférences locales sélectionnent le provider et les extensions, tandis que l’outil todo structure le plan d’action en phases ordonnées.
2. Exploration & Parallélisation : Pendant que l’agent principal élabore la logique métier, un sous-agent Explore est détaché en arrière-plan dans un Git worktree isolé avec une allowlist en lecture seule pour chercher des exemples d’implémentation sur grep_app ou extraire la documentation via context7.
3. Sécurité & Contrôle Distant : Si une décision critique ou une commande shell sensible se présente alors que je suis en déplacement, une notification interactive arrive sur mon application Discord. Un simple clic valide le choix et l’agent poursuit son exécution.
4. Continuité Cognitive : Grâce à observational-memory, les enseignements tirés de chaque session (bugs résolus, préférences de framework, conventions d’API) persistent dans SQLite et enrichissent automatiquement les sessions futures. Les transcripts et les loadouts des sous-agents permettent également de reprendre un travail interrompu sans élargir ses permissions.

Conclusion

L’efficacité d’un agent de développement ne dépend pas uniquement de la puissance intrinsèque du modèle sous-jacent, mais de la richesse et de la robustesse de son environnement d’exécution.

En réunissant mémoire persistante déterministe, concurrence asynchrone, passerelle MCP connectée à un VPS Zero Trust, interactivité multi-canaux (TUI + Discord) et garde-fous de sécurité, cette stack transforme Pi en un véritable partenaire d’ingénierie logicielle autonome, fiable et taillé pour la production.