Harness and Agent : L'Architecture en Couches des Systèmes d'IA

Du Protocole MCP à la Conception des Couches d'Outils et d'Agent de MCPlato

---

1. Introduction : L'Éveil Architecturaux des Systèmes d'IA

De la Suprématie du Modèle à la Suprématie de l'Architecture

Ces trois dernières années, l'industrie de l'IA a été obsédée par une métrique singulière : la capacité du modèle. Les scores de benchmark, les nombres de paramètres et les tailles de fenêtre de contexte ont dominé les discussions techniques. L'hypothèse implicite était claire — meilleur est le modèle, meilleur est le système.

Mais quelque chose a changé en 2024.

Alors que les Grands Modèles de Langage (LLM) franchissaient le seuil du "suffisamment bon" pour la plupart des tâches pratiques, les praticiens ont découvert une vérité déconcertante : le goulot d'étranglement dans les systèmes d'IA est rarement le modèle lui-même. Un modèle de classe GPT-4 avec une mauvaise intégration d'outils performe moins bien qu'un modèle de classe GPT-3.5 avec une couche d'outils bien conçue. Le foyer de la compétition s'est déplacé de l'intelligence brute vers l'élégance architecturale.

Pourquoi la Couche Harness est Plus Importante que le Modèle

Considérez ce scénario : Vous avez accès au modèle d'IA le plus capable au monde. Il peut raisonner sur des problèmes complexes, écrire du code sophistiqué et comprendre des instructions nuancées. Mais lorsqu'il tente d'interagir avec le monde réel — lire des fichiers, appeler des API, naviguer sur des sites web — il le fait via des outils mal conçus, mal formatés et implémentés de manière non sécurisée.

Le résultat ? Frustration, erreurs et échec final à fournir de la valeur.

La couche Harness (aussi connue sous le nom de couche d'outils) représente tout ce qui permet à une IA d'interagir avec le monde externe : définitions d'outils, environnements d'exécution, politiques de sécurité, gestion des erreurs, formatage des résultats et gestion de la mémoire. C'est la différence entre un esprit brillant piégé dans une pièce et un esprit équipé pour agir sur le monde.

Le Défi Central : Utilisation Sûre et Fiable des Outils

La question fondamentale à laquelle l'architecture moderne de l'IA doit faire face est décevantement simple : Comment permettons-nous aux agents d'utiliser les outils de manière sûre, fiable et efficace ?

Cette question englobe :

• Sécurité : Comment empêchons-nous l'accès non autorisé aux fichiers, l'exfiltration de données ou l'exécution de code malveillant ?
• Fiabilité : Comment nous assurons-nous que les outils se comportent de manière cohérente, gèrent les erreurs avec élégance et se remettent des échecs ?
• Composabilité : Comment permettons-nous aux agents de combiner plusieurs outils pour accomplir des tâches complexes ?
• Découvrabilité : Comment les agents savent-ils quels outils sont disponibles et quand les utiliser ?

Répondre à ces questions nécessite une approche architecturale délibérée — une qui sépare les préoccupations, établit des interfaces claires et privilégie la robustesse plutôt que la commodité.

---

2. Architecture en Couches : Le Modèle Théorique de Harness et Agent

Pour relever ces défis, nous proposons une séparation claire des préoccupations entre deux couches architecturales distinctes : la Couche Harness et la Couche Agent. Cette séparation n'est pas simplement organisationnelle — elle reflète des responsabilités, des modes de défaillance et des cibles d'optimisation fondamentalement différents.

2.1 La Couche Harness (Couche d'Outils)

La couche Harness sert d'interface entre le raisonnement de l'IA et le monde externe. Ses responsabilités sont concrètes, opérationnelles et principalement concernées par l'exécution plutôt que la prise de décision.

Responsabilités Fondamentales

Insight Clé : La Harness Gère "Tout le Reste"

La caractéristique déterminante de la couche Harness est qu'elle gère tout ce qui est extérieur au raisonnement pur du modèle. Lorsqu'un modèle génère un plan pour "analyser le CSV de données de ventes et générer un rapport récapitulatif", la couche Harness :

• Localise et lit le fichier CSV
• Valide les permissions et le format du fichier
• Exécute l'analyse (potentiellement en invoquant du code)
• Gère toutes erreurs ou cas limites
• Formate les résultats pour la consommation par le modèle
• Gère les ressources temporaires et le nettoyage

Le modèle se concentre sur ce qui devrait être fait ; la Harness s'assure que cela peut être fait en toute sécurité et de manière fiable.

2.2 La Couche Agent (Couche Proxy)

Si la couche Harness concerne l'exécution, la couche Agent concerne la prise de décision. Elle opère à un niveau d'abstraction plus élevé, concernée par les objectifs, les plans et les stratégies plutôt que par les invocations d'outils spécifiques.

Responsabilités Fondamentales

Insight Clé : L'Agent Opère via des Abstractions

La couche Agent ne manipule pas directement les fichiers ou n'exécute pas de code. Au lieu de cela, elle opère via des abstractions des outils — comprenant leurs capacités, leurs limitations et leurs cas d'usage appropriés. Lorsqu'un agent décide de "rechercher de la documentation pertinente", il délègue l'opération de recherche réelle à la couche Harness, faisant confiance à ce que la Harness gérera les spécificités de la formulation de requêtes, de l'invocation d'API et de la récupération des résultats.

2.3 Modèle d'Interaction : Un Diagramme de Flux Textuel

La relation entre Agent et Harness suit un modèle requête-réponse avec des limites claires :

┌─────────────────────────────────────────────────────────────────────┐
│                         FLUX D'INTERACTION                          │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌──────────────┐     Découverte d'Outils  ┌──────────────────────┐   │
│  │              │ ─────────────────────>   │                      │   │
│  │    AGENT     │                          │       HARNESS        │   │
│  │    LAYER     │                          │       LAYER          │   │
│  │              │ <─────────────────────   │                      │   │
│  │              │     Manifeste d'Outils   │                      │   │
│  └──────┬───────┘                          └──────────────────────┘   │
│         │                                                             │
│         │  1. L'Agent analyse la tâche et sélectionne l'outil approprié│
│         │  2. L'Agent formule une requête d'appel avec paramètres    │
│         │                                                             │
│         ▼                                                             │
│  ┌─────────────────────────────────────────────────────────────┐      │
│  │                    REQUÊTE D'INVOCATION                      │      │
│  │  {                                                         │      │
│  │    "tool": "file_read",                                     │      │
│  │    "params": { "path": "/data/sales.csv" },                  │      │
│  │    "context": { "session_id": "abc123" }                     │      │
│  │  }                                                         │      │
│  └─────────────────────────────────────────────────────────────┘      │
│         │                                                             │
│         ▼                                                             │
│  ┌─────────────────────────────────────────────────────────────┐      │
│  │                    TRAITEMENT HARNESS                        │      │
│  │                                                              │      │
│  │  ┌──────────────┐   ┌──────────────┐   ┌──────────────┐     │      │
│  │  │   Valider    │ ─>│   Exécuter   │ ─>│   Formater   │     │      │
│  │  │   Requête    │   │    Outil     │   │   Résultat   │     │      │
│  │  └──────────────┘   └──────────────┘   └──────────────┘     │      │
│  │                                                              │      │
│  └─────────────────────────────────────────────────────────────┘      │
│         │                                                             │
│         ▼                                                             │
│  ┌─────────────────────────────────────────────────────────────┐      │
│  │                    MESSAGE DE RÉPONSE                        │      │
│  │  {                                                         │      │
│  │    "status": "success",                                     │      │
│  │    "result": { "content": "...", "metadata": {...} },        │      │
│  │    "elapsed_ms": 150                                       │      │
│  │  }                                                         │      │
│  └─────────────────────────────────────────────────────────────┘      │
│         │                                                             │
│         ▼                                                             │
│  ┌──────────────┐                                                     │
│  │    AGENT     │  ← L'Agent intègre le résultat, continue le raisonnement│
│  └──────────────┘                                                     │
│                                                                       │
└─────────────────────────────────────────────────────────────────────┘

2.4 Les Bénéfices de la Séparation

Cette architecture en couches fournit plusieurs avantages critiques :

1. Évolution Indépendante La couche Harness peut être étendue avec de nouveaux outils sans modifier la couche Agent. Lorsqu'une nouvelle API devient disponible, seule l'implémentation de l'outil doit changer — l'Agent voit simplement une nouvelle capacité dans le manifeste d'outils.

2. Reproductibilité et Testabilité Les opérations Harness sont déterministes et testables. Vous pouvez vérifier qu'une opération de lecture de fichier fonctionne correctement indépendamment de la décision de l'Agent de lire ce fichier. Cette séparation permet les tests unitaires aux deux couches.

3. Limites de Sécurité Les politiques de sécurité sont appliquées au niveau de la couche Harness, créant une limite dure que les agents ne peuvent pas contourner. Même si un agent est compromis ou induit en erreur, il opère dans les contraintes du bac à sable Harness.

4. Support Multi-Agent Plusieurs agents peuvent partager la même couche Harness, bénéficiant chacun d'un comportement d'outil cohérent et de politiques de sécurité. Cela permet des scénarios collaboratifs où différents agents gèrent différents aspects d'une tâche complexe.

---

3. Protocole MCP : L'Interface USB-C pour l'IA

En novembre 2024, Anthropic a publié le Model Context Protocol (MCP), un standard ouvert qui promet de faire pour l'intégration des outils d'IA ce que l'USB-C a fait pour la connectivité des appareils : fournir une interface unique et universelle qui élimine la fragmentation et permet une véritable interopérabilité.

3.1 Le Problème que MCP Résout

Avant MCP, l'intégration d'une nouvelle source de données ou d'un nouvel outil dans une application d'IA nécessitait généralement de construire un connecteur personnalisé. Vous voulez que votre IA interroge une base de données Postgres ? Écrivez un connecteur. Vous voulez qu'elle accède au CRM de votre entreprise ? Écrivez un autre connecteur. Chaque intégration était sur mesure, fragile et liée à des plateformes d'IA spécifiques.

MCP élimine ce coût d'intégration en définissant un protocole standard pour la manière dont les applications d'IA se connectent aux systèmes externes. Au lieu de N×M intégrations (N outils × M plateformes d'IA), MCP permet N+M intégrations (chaque outil implémente MCP une fois, chaque plateforme supporte MCP une fois).

3.2 Architecture MCP : Trois Rôles Fondamentaux

MCP définit trois rôles architecturaux qui correspondent à différentes responsabilités dans l'écosystème d'outils :

┌─────────────────────────────────────────────────────────────────────┐
│                      ARCHITECTURE MCP                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌──────────────┐         ┌──────────────┐         ┌────────────┐  │
│   │              │         │              │         │            │  │
│   │    HOST      │◄───────►│    CLIENT    │◄───────►│   SERVER   │  │
│   │              │         │              │         │            │  │
│   │  App IA      │         │ Gestion de   │         │ Fournisseur│  │
│   │  (MCPlato,   │         │ Connexion    │         │ Outil/Données│  │
│   │  Claude,     │         │              │         │            │  │
│   │  Cursor)     │         │ • Traitement │         │ • Tools    │  │
│   │              │         │   Protocole  │         │ • Resources│  │
│   │ Orchestre    │         │ • Découverte │         │ • Prompts  │  │
│   │ l'interaction│         │   Capacités  │         │            │  │
│   │              │         │ • Gestion    │         │            │  │
│   │              │         │   État       │         │            │  │
│   └──────────────┘         └──────────────┘         └────────────┘  │
│                                                                     │
│   Responsabilités :                                                   │
│   • HOST : UX, orchestration, gestion du cycle de vie                │
│   • CLIENT : Conformité protocole, négociation des capacités         │
│   • SERVER : Implémentation outil, accès données, exécution          │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

3.3 Primitives Fondamentales MCP

MCP définit trois primitives fondamentales que les serveurs peuvent fournir :

Tools (Fonctions Exécutables) Les Tools sont des fonctions qui effectuent des actions — lecture de fichiers, interrogation de bases de données, envoi de messages ou exécution de code. Ils acceptent des paramètres structurés et retournent des résultats structurés. Les Tools sont explicitement invoqués par l'IA basé sur le contexte et le besoin.

{
  "name": "file_read",
  "description": "Lire le contenu d'un fichier",
  "inputSchema": {
    "type": "object",
    "properties": {
      "path": { "type": "string", "description": "Chemin du fichier" }
    },
    "required": ["path"]
  }
}

Resources (Sources de Données) Les Resources représentent les données auxquelles l'IA peut faire référence — contenu de fichiers, schémas de bases de données, documentation API ou fichiers de configuration. Contrairement aux Tools, les Resources sont généralement en lecture seule et servent de contexte plutôt que d'actions.

Prompts (Modèles d'Interaction) Les Prompts fournissent des modèles ou patterns d'interaction prédéfinis qui guident le comportement de l'IA pour des tâches spécifiques. Ils peuvent inclure des instructions système, des exemples d'interactions ou des formats de requête structurés.

3.4 Pourquoi MCP est Important pour l'Architecture

MCP est plus qu'une commodité — il représente un changement fondamental dans la manière dont nous pensons l'intégration des outils d'IA :

La Standardisation Permet la Compétition Lorsque les outils implémentent un standard commun, la compétition passe de "qui a le plus d'intégrations" à "qui fournit la meilleure expérience avec ces intégrations". Cela bénéficie aux utilisateurs et stimule l'innovation tant dans la qualité des outils que dans les capacités de l'IA.

Le Découplage Permet la Spécialisation Avec MCP, les développeurs d'outils peuvent se concentrer sur la construction de bons outils sans se soucier de la compatibilité avec les plateformes d'IA. Les plateformes d'IA peuvent se concentrer sur l'orchestration et le raisonnement sans maintenir d'innombrables connecteurs personnalisés.

La Composabilité Permet les Écosystèmes MCP crée des effets de réseau : chaque nouveau serveur MCP bénéficie à tous les hosts compatibles MCP, et chaque nouveau host MCP crée de la valeur pour tous les serveurs existants. Cet effet de flywheel accélère la croissance de l'écosystème.

---

4. Pratique Architecturale de MCPlato

MCPlato représente une implémentation concrète de l'architecture en couches Harness-Agent, construite avec MCP comme principe fondamental plutôt qu'après-coup. Sa conception reflète les leçons tirées à la fois de la recherche académique et du déploiement pratique des systèmes d'IA.

4.1 Modèle d'Architecture à Trois Couches

L'architecture de MCPlato est organisée autour de trois couches distinctes, chacune avec des responsabilités et des limites claires :

┌─────────────────────────────────────────────────────────────────────┐
│                    ARCHITECTURE MCPLATO                             │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    COUCHE WORKSPACE                          │    │
│  │                                                              │    │
│  │  • Gestion et isolation des workspaces                        │    │
│  │  • Montage multi-répertoires                                  │    │
│  │  • Mémoire cross-session (Diary)                              │    │
│  │  • Configuration de l'environnement                           │    │
│  │                                                              │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              ▲                                      │
│                              │                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    COUCHE SESSION                            │    │
│  │                                                              │    │
│  │  • Maintien du contexte et historique des messages            │    │
│  │  • Routage et distribution des messages                       │    │
│  │  • Gestion d'état au niveau session                           │    │
│  │  • Coordination multi-session                                 │    │
│  │                                                              │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                              ▲                                      │
│                              │                                      │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                     COUCHE AGENT                             │    │
│  │                                                              │    │
│  │  • Exécution autonome ClawMode                                │    │
│  │  • Planification et décomposition des tâches                  │    │
│  │  • Sélection et invocation d'outils                           │    │
│  │  • Raisonnement et récupération multi-étapes                  │    │
│  │                                                              │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │                    COUCHE HARNESS                            │    │
│  │                                                              │    │
│  │  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────┐ │    │
│  │  │   @Tool     │ │ Infographic │ │   Browser   │ │  PDF   │ │    │
│  │  │   Suite     │ │   Creator   │ │ Automation  │ │ Tools  │ │    │
│  │  └─────────────┘ └─────────────┘ └─────────────┘ └────────┘ │    │
│  │                                                              │    │
│  │  ┌─────────────┐ ┌─────────────┐ ┌────────────────────────┐ │    │
│  │  │    MCP      │ │  Image Gen  │ │   Document Analysis    │ │    │
│  │  │   Host      │ │   & Edit    │ │   (OCR/Understanding)  │ │    │
│  │  └─────────────┘ └─────────────┘ └────────────────────────┘ │    │
│  │                                                              │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Couche Workspace

La couche Workspace fournit des limites organisationnelles et un stockage persistant qui s'étend sur les sessions individuelles. C'est le niveau d'abstraction le plus élevé dans la hiérarchie de MCPlato.

Capacités clés :

• Isolation : Chaque workspace maintient une configuration séparée, des répertoires montés et des variables d'environnement
• Montage multi-répertoires : Les workspaces peuvent inclure plusieurs répertoires de projet, permettant des workflows inter-projets
• Mémoire persistante : Le système Diary maintient une mémoire à long terme à travers les sessions, préservant les insights et les décisions
• Gestion de l'environnement : Configuration au niveau workspace pour les serveurs MCP, les outils personnalisés et les paramètres de comportement

Couche Session

La couche Session gère le contexte d'interaction immédiat — les messages, l'état et les données éphémères associés à une conversation ou tâche spécifique.

Capacités clés :

• Maintien du contexte : Historique des messages, résultats d'outils et état intermédiaire au sein d'une session
• Routage des messages : Distribution des entrées utilisateur aux gestionnaires appropriés et routage des sorties en retour
• Exécution parallèle : Support pour plusieurs sessions concurrentes au sein d'un seul workspace
• Persistance d'état : Capacité à sauvegarder et reprendre l'état de session pour les tâches de longue durée

Couche Agent

La couche Agent implémente les capacités de raisonnement et de prise de décision du système, incarnées dans le moteur d'exécution autonome ClawMode de MCPlato.

Capacités clés :

• Exécution autonome : ClawMode permet à l'Agent de travailler indépendamment, en prenant des décisions sans entrée utilisateur constante
• Planification des tâches : Décomposition des objectifs complexes en étapes actionnables avec gestion des dépendances
• Coordination multi-session : Orchestration du travail à travers plusieurs sessions pour une exécution parallèle ou séquentielle
• Auto-amélioration : La capacité d'apprendre des patterns d'exécution et d'optimiser le comportement futur

4.2 Caractéristiques d'Intégration Harness

La couche Harness de MCPlato se distingue par plusieurs décisions de conception clés :

Support MCP Natif

Contrairement aux systèmes qui ajoutent le support MCP comme plugin ou extension, MCPlato implémente MCP comme principe architectural fondamental :

• Host MCP Intégré : Implémentation complète de Host MCP avec support pour les transports stdio et HTTP
• Gestion dynamique des serveurs : Ajout, suppression et configuration à l'exécution des serveurs MCP
• Découverte des capacités : Détection et exposition automatiques des outils, resources et prompts disponibles
• Hot-loading : De nouveaux serveurs MCP peuvent être ajoutés sans redémarrer l'application

Suite d'Outils Intégrée

Au-delà de MCP, MCPlato fournit un ensemble complet d'outils intégrés conçus pour les workflows de productivité :

Chaque outil dans la suite intégrée suit les mêmes standards d'interface que les outils MCP, assurant un comportement cohérent que l'on utilise des capacités natives ou des serveurs externes.

Découverte Dynamique des Outils

La couche Harness implémente des mécanismes sophistiqués de découverte d'outils :

• Introspection à l'exécution : Les outils font connaître leurs capacités, paramètres et exigences dynamiquement
• Correspondance sémantique : L'Agent peut découvrir des outils basés sur des descriptions en langage naturel des besoins
• Gestion de versions : Support pour plusieurs versions du même outil avec obsolescence gracieuse
• Résolution de dépendances : Traitement automatique des dépendances d'outils et vérifications des prérequis

4.3 Capacités de l'Agent

La couche Agent de MCPlato (ClawMode) implémente plusieurs capacités avancées qui la distinguent des interfaces simples basées sur le chat :

Planification et Décomposition des Tâches

Lorsqu'on lui présente des objectifs complexes, l'Agent :

1. Analyse l'objectif pour identifier les étapes requises et les dépendances
2. Sélectionne les outils appropriés pour chaque étape
3. Établit des critères de succès et des points de contrôle
4. Crée un plan d'exécution récupérable qui peut survivre aux interruptions

Coordination Multi-Session

L'Agent peut orchestrer le travail à travers plusieurs sessions :

• Exécution parallèle : Exécution de sous-tâches indépendantes dans des sessions séparées
• Pipelines séquentiels : Chaînage de sessions où la sortie de l'une devient l'entrée de l'autre
• Mémoire cross-session : Partage de contexte pertinent entre sessions tout en maintenant l'isolation

Support des Tâches de Longue Durée

MCPlato supporte les tâches qui s'étendent au-delà d'une seule interaction :

• Exécution planifiée : Planification de tâches basée sur Cron et périodique
• Point de contrôle et reprise : Sauvegarde de l'état aux jalons clés pour récupération
• Rapport de progression : Mises à jour en temps réel sur les opérations de longue durée
• Human-in-the-loop : Points d'escalade appropriés pour les décisions nécessitant le jugement humain

---

5. Comparaison Architecturale Compétitive

Pour comprendre les choix architecturaux de MCPlato, il est utile de les comparer avec d'autres systèmes dans le paysage des Agents d'IA. Le tableau suivant résume les différences architecturales clés :

5.1 Analyse des Choix de Conception

Claude Code privilégie la simplicité et l'intégration avec les workflows développeurs existants. Son Harness est léger, se concentrant sur les opérations essentielles de fichiers et de terminal. La couche Agent maintient une seule session de longue durée, ce qui simplifie la gestion du contexte mais limite la parallélisation.

Cursor met l'accent sur la productivité des développeurs dans un contexte IDE. Son Harness exploite les capacités existantes de l'éditeur tout en ajoutant le support MCP pour l'extensibilité. L'architecture Agent 2.0 introduit l'autonomie dans le contexte limité de l'édition de code.

OpenClaw (le fondement open-source de MCPlato) fournit une flexibilité maximale grâce à sa hiérarchie Gateway-Agent-Tools. En tant que framework plutôt que produit, il privilégie la configurabilité par rapport à l'expérience prête à l'emploi.

Devin représente l'extrême cloud-native : l'environnement entier est virtualisé et géré. Cela permet des capacités puissantes mais nécessite d'abandonner le contrôle à l'infrastructure cloud.

MCPlato occupe une position distinctive : il combine la flexibilité d'OpenClaw avec le polissage au niveau produit, ajoute les principes Local First et implémente une architecture à trois couches qui sépare clairement les préoccupations.

5.2 Facteurs Clés de Différenciation

---

6. Principes de Conception Architecturale et Bonnes Pratiques

Basé sur l'analyse de MCPlato et des systèmes comparables, nous pouvons extraire plusieurs principes pour concevoir des architectures Harness-Agent efficaces :

6.1 Principe 1 : Découplage en Couches

Les couches Harness et Agent devraient avoir des interfaces claires et stables.

• Définissez des contrats explicites entre les couches (les protocoles comme MCP fournissent ceux-ci)
• Évitez de fuir les détails d'implémentation à travers les limites de couche
• Permettez les tests, déploiement et évolution indépendants de chaque couche
• Résistez à la tentation d'ajouter des raccourcis de "commodité" qui brouillent les responsabilités des couches

6.2 Principe 2 : Standards d'Abord

Adoptez les standards ouverts avant de construire des solutions personnalisées.

• Les standards comme MCP fournissent des bénéfices immédiats à l'écosystème
• Les protocoles personnalisés créent de la dette technique et des défis d'intégration
• Les standards émergent de la sagesse collective — respectez ce savoir accumulé
• Contribuez à l'évolution des standards plutôt que de faire des forks inutiles

6.3 Principe 3 : Découverte Dynamique

Les outils devraient être découvrables à l'exécution, pas codés en dur.

• Les agents devraient s'adapter aux outils disponibles sans changements de code
• Les manifestes d'outils devraient inclure des métadonnées riches (description, paramètres, exemples)
• Supportez le hot-loading pour les mises à jour d'outils sans temps d'arrêt
• Permettez le chaînage et la composition d'outils via des interfaces standard

6.4 Principe 4 : Isolation de Sécurité

L'exécution des outils devrait être en bac à sable et appliquée par politique.

• Partez du principe que l'Agent peut faire des erreurs ou être induit en erreur
• Implémentez la défense en profondeur : validation à plusieurs niveaux
• Utilisez le principe du moindre privilège — les outils n'obtiennent que les permissions dont ils ont besoin
• Fournissez des pistes d'audit claires pour les opérations sensibles à la sécurité

6.5 Principe 5 : Persistance de l'État

Les tâches de longue durée nécessitent une gestion d'état robuste.

• Concevez pour l'interruption — les tâches seront mises en pause, tuées ou échoueront
• Implémentez des mécanismes de point de contrôle/restauration aux limites de tâches
• Séparez l'état éphémère de l'état persistant
• Permettez une dégradation gracieuse lorsque l'état est perdu

6.6 Liste de Contrôle des Bonnes Pratiques

Lors de l'implémentation d'une architecture Harness-Agent, considérez :

• Définition d'Outil : Les outils sont-ils bien documentés avec des schémas clairs et des exemples ?
• Gestion des Erreurs : Les outils fournissent-ils des messages d'erreur actionnables et des suggestions de récupération ?
• Observabilité : Pouvez-vous tracer une requête de la décision de l'Agent à l'exécution du Harness ?
• Limitation de Débit : Y a-t-il des protections contre l'abus accidentel ou les boucles infinies ?
• Contrôle Utilisateur : Les utilisateurs peuvent-ils inspecter, approuver ou remplacer les sélections d'outils de l'Agent ?
• Stratégie de Secours : Que se passe-t-il lorsque les outils préférés ne sont pas disponibles ?
• Nettoyage des Ressources : Les fichiers temporaires, connexions et processus sont-ils correctement libérés ?

---

7. Conclusion : L'Architecture comme Avantage Compétitif

En regardant vers l'avenir des systèmes d'IA, un modèle clair émerge : la capacité du modèle se banalise, mais l'excellence architecturale reste un avantage compétitif durable.

7.1 Le Plateau de la Capacité des Modèles

L'écart entre les modèles de pointe et les alternatives open-source capables se rétrécit. Des techniques comme la distillation, la quantification et l'entraînement efficace démocratisent l'accès à des capacités de raisonnement puissantes. Dans quelques années, la "qualité du modèle" sera un problème résolu pour la plupart des applications.

Ce qui ne sera pas résolu est le défi de l'intégration — connecter ces modèles capables à la réalité hétérogène et chaotique des systèmes d'entreprise, des workflows personnels et des sources de données externes. C'est le domaine de l'architecture.

7.2 La Fiabilité du Harness comme Facteur Décisif

Lorsque les modèles sont "suffisamment bons", les facteurs décisifs deviennent :

• Fiabilité : Le système fonctionne-t-il de manière cohérente à travers divers scénarios ?
• Sécurité : Les utilisateurs peuvent-ils faire confiance au système avec leurs données et systèmes ?
• Extensibilité : Le système peut-il s'adapter à de nouvelles exigences sans être redessiné ?
• Observabilité : Les opérateurs peuvent-ils comprendre et déboguer le comportement du système ?

Ce sont des préoccupations architecturales, pas des préoccupations de modèle. La couche Harness est où ces préoccupations sont adressées.

7.3 MCP et l'Unification de l'Accès aux Outils

MCP représente un moment charnière dans l'architecture de l'IA — l'émergence d'un véritable standard pour l'intégration d'outils. À mesure que l'adoption de MCP croît, nous pouvons nous attendre à :

• Une croissance explosive des outils disponibles (chaque produit SaaS, base de données et API devient accessible à l'IA)
• Une compétition accrue entre les plateformes d'IA sur la qualité d'orchestration plutôt que la quantité d'intégrations
• L'émergence de fournisseurs de Harness spécialisés (axés sur la sécurité, optimisés pour les performances, spécifiques au domaine)

7.4 De l'Agent Unique à la Collaboration Multi-Agent

La génération actuelle de systèmes d'IA traite largement l'Agent comme une entité singulière. La prochaine génération adoptera des architectures multi-Agent où des Agents spécialisés collaborent sur des tâches complexes :

• Des Agents de recherche qui collectent et synthétisent l'information
• Des Agents de planification qui décomposent les objectifs et allouent les ressources
• Des Agents d'exécution qui interagissent avec des systèmes et outils spécifiques
• Des Agents de révision qui vérifient la qualité et détectent les erreurs

Ces systèmes multi-Agent nécessiteront des couches Harness sophistiquées capables de :

• Communication et coordination inter-Agent
• Gestion de contexte partagé à travers les limites d'Agent
• Résolution de conflits lorsque les Agents sont en désaccord
• Allocation et priorisation des ressources

L'architecture à trois couches de MCPlato — avec sa séparation claire des préoccupations de Workspace, Session et Agent — fournit une fondation pour ce futur multi-Agent.

7.5 Réflexions Finales

La transition de la pensée "modèle-d'abord" à "architecture-d'abord" représente une maturation du domaine de l'IA. Nous passons d'une ère de démonstration de ce qui est possible à une ère de livraison de ce qui est fiable.

Pour les praticiens construisant des systèmes d'IA aujourd'hui, la leçon est claire : investissez dans votre couche Harness. Un Harness bien conçu survivra à votre fournisseur de modèle actuel, s'adaptera à de nouveaux cas d'usage et fournira la fondation pour des capacités encore à imaginer.

L'architecture de MCPlato — MCP-natif, découplée à trois couches, Local First — représente une vision de ce à quoi cette fondation peut ressembler. Ce n'est pas la seule approche valide, mais elle démontre les principes qui guideront les architectures d'IA réussies dans les années à venir.

L'ère de l'IA architecture-d'abord a commencé.

---

FAQ

Q : Qu'est-ce que la couche Harness dans les systèmes d'IA ?

La couche Harness (couche d'outils) est responsable de l'encapsulation des outils, de l'orchestration de l'exécution, de la validation et de la protection, ainsi que de la gestion de la mémoire. Elle encapsule les capacités externes (fichiers, API, recherche) dans des Tools/Skills appelables et gère toutes les fonctionnalités au-delà du raisonnement du modèle, y compris le bac à sable de sécurité, la gestion des erreurs et le formatage des résultats.

Q : Comment MCPlato implémente-t-il l'architecture Harness-Agent ?

MCPlato implémente une architecture à trois couches : la couche Workspace pour la gestion et l'isolation des workspaces, la couche Session pour le maintien du contexte et la distribution des messages, et la couche Agent pour l'exécution autonome ClawMode. Il fournit des capacités de Host MCP natives, des ensembles d'outils intégrés incluant @Tool, Infographic, Browser, Image et Document, et supporte la découverte dynamique des outils et le hot-loading.

Q : Qu'est-ce que MCP et pourquoi est-ce important ?

MCP (Model Context Protocol) est un standard ouvert publié par Anthropic en novembre 2024. Il sert d'interface universelle entre les applications d'IA et les systèmes externes, éliminant la nécessité de construire des connecteurs séparés pour chaque source de données. MCP définit trois primitives fondamentales : Tools (fonctions exécutables), Resources (sources de données) et Prompts (modèles d'interaction).

Q : Pourquoi la couche Harness est-elle plus importante que le modèle lui-même ?

Au-delà d'un certain seuil, les capacités des modèles deviennent banalisées. La fiabilité, la sécurité et la qualité de l'intégration des outils de la couche Harness deviennent les facteurs décisifs pour les systèmes d'IA en production. Un Harness bien conçu permet une utilisation sûre et fiable des outils tout en fournissant des interfaces cohérentes indépendamment du modèle sous-jacent.

Q : Quels sont les principes clés pour concevoir des architectures Harness-Agent ?

Les principes clés incluent : (1) Le découplage en couches avec une séparation claire des responsabilités de Harness et Agent, (2) L'adoption prioritaire des standards comme MCP, (3) La découverte dynamique pour l'enregistrement des outils à l'exécution, (4) L'isolation de sécurité via l'exécution en bac à sable, et (5) La persistance de l'état pour les tâches de longue durée.

Q : Comment MCPlato diffère-t-il de Claude Code et Cursor ?

MCPlato se distingue par : (1) Une architecture à trois couches vs. des conceptions à deux couches, (2) Une implémentation native de Host MCP vs. un support additionnel, (3) Local First avec une chaîne d'outils locale complète, (4) Des outils d'image, de document, d'infographie et de navigateur intégrés, (5) Une architecture mémoire à trois niveaux, et (6) Des capacités de planification natives.

Q : Quelle est la direction future pour l'architecture des systèmes d'IA ?

L'industrie évolue de l'Agent unique vers la collaboration multi-Agent, de la conception centrée sur le modèle vers la conception centrée sur l'architecture, et des intégrations propriétaires vers des protocoles standardisés comme MCP. Les futurs systèmes mettront l'accent sur la fiabilité, l'observabilité et l'extensibilité comme objectifs de conception principaux.