Agents

Harness IA et agents de code en 2026 : le harness compte plus que le modèle

Coding tools vs agents autonomes, tool calling, boucles agentiques, mémoire projet et benchmarks 2026 : pourquoi le harness fait la différence.

Par Antoine Michéa, Fondateur & ingénieur infrastructure · · mis à jour le

Un modèle ne suffit plus. Ce qui distingue Claude Code, Cursor, Codex CLI ou Aider, ce n’est pas tellement le LLM qu’ils utilisent — c’est le harness qui orchestre ce LLM avec des outils, du contexte et une boucle de décision. Comprendre cette couche est devenu indispensable en 2026.

Qu’est-ce qu’un harness ?

Un harness est la fine couche logicielle qui transforme un LLM (qui ne sait que générer du texte) en système exécutif capable d’agir : lire des fichiers, lancer des commandes, modifier du code, requêter une API.

1. System prompt + outils + contexte projet
   (ex: CLAUDE.md, AGENTS.md, fichiers ouverts)
        ▼
2. Le LLM génère du texte + des tool_calls JSON
        ▼
3. Le harness intercepte les tool_calls
   → exécute (Read, Bash, Edit, Grep, WebFetch…)
   → valide les permissions, sandboxe
   → ajoute le résultat au contexte
        ▼
4. Boucle jusqu'à ce que le LLM dise « fini »
   ou qu'une limite (tokens, étapes) soit atteinte

Le cœur d’un harness tient en quelques dizaines de lignes. Toute la différenciation se joue dans le tuning : prompts système, descriptions d’outils, gestion du contexte.

Coding tool vs agent : deux catégories

Coding tool (pair-programmer) — l’utilisateur dirige chaque étape : il sélectionne les fichiers, valide chaque diff, relance manuellement. Le LLM est un assistant rapide, jamais autonome. Exemples : Aider, Cline, Codex CLI, GitHub Copilot, Cursor en mode chat.

Agent orchestrator (autonome) — on lui donne un objectif multi-étapes ; l’agent planifie, lit, modifie, teste, itère sur plusieurs fichiers et plusieurs heures sans intervention. Exemples : Claude Code, Devin, Pi en mode RPC, OpenCode en mode autonome.

L’effet harness, mesuré

Un même Claude Opus, testé dans deux harness sur un même corpus de tâches : 77 % dans un harness, 93 % dans un autre. Même modèle, mêmes tâches, +16 points uniquement à cause du harness. En général, la qualité du harness fait varier les scores de 5 à 40 points, indépendamment du modèle.

Les acteurs majeurs en 2026

Claude Code (Anthropic)

  • Force : exécutions autonomes longues (overnight runs), changements multi-fichiers, refactorings d’architecture.
  • Contexte projet : CLAUDE.md, mémoire persistante par dépôt, chargée à chaque conversation.
  • Sub-agents : parallélisation de tâches indépendantes (Explore, code-reviewer…).
  • Hooks : commandes shell sur événements (PostToolUse, SessionStart…).
  • MCP : Model Context Protocol pour brancher des outils externes.
  • Faiblesse : consommation de tokens 3–4× supérieure à Codex CLI sur tâches comparables.

Codex CLI (OpenAI)

  • Force : apps focalisées (iOS, macOS, web), efficacité tokens (~×4 vs Claude Code).
  • Sandbox : exécution dans un container cloud isolé.
  • AGENTS.md : équivalent ouvert de CLAUDE.md, désormais standardisé.
  • Faiblesse : perd la cohérence après 3–4 étapes de chaîne complexe.

Aider

  • Force : Git-first (chaque édition devient un commit), traçabilité totale, économie de tokens.
  • Multi-fournisseur : Claude, GPT, Gemini, DeepSeek, Qwen, Ollama local.
  • Auto-lint + auto-test après chaque modification.
  • Repo map : index sémantique compressé du dépôt, sans saturer le contexte.

Cursor

  • Force : intégration IDE supérieure, autocomplétion contextualisée, mode chat + agent.
  • Composer : agent multi-fichier supervisé, validation diff par diff.
  • Design Mode : conversion mockup (Figma, screenshot) → implémentation.
  • Faiblesse : pas vraiment autonome, s’arrête sur les ambiguïtés.

OpenCode

  • Force : 75+ providers LLM via une seule interface.
  • Idéal pour expérimenter avec Claude, GPT, Qwen, DeepSeek, Ollama local.
  • Faiblesse : moins mature en opération autonome longue, pas de sub-agents.

Pi (Continue.dev)

  • Force : harness minimal, primitives configurables, mode RPC pour embarquer dans une app.
  • Session tree : historique en arbre, fork / rollback possibles.
  • Idéal avec GPT ou modèles open-weight.

Tableau de décision

BesoinOutil recommandéAlternative
Tâches autonomes longues (overnight)Claude CodeDevin, Pi en RPC
App iOS / macOS / web cibléeCodex CLICursor
Budget limité, audit Git strictAiderOpenCode
Expérimenter plusieurs modèlesOpenCodeAider
Contrôle total / embarquéPiSDK Anthropic / OpenAI
IDE quotidien superviséCursorContinue.dev, Zed
Local 100 % (souveraineté)Aider + OllamaOpenCode + llama.cpp

Tool calling : le contrat sous le capot

Toute la mécanique repose sur le tool calling : le LLM émet des appels d’outils en JSON, le harness les exécute et réinjecte le résultat. La fiabilité de cette boucle dépend du respect strict du contrat de l’API.

C’est exactement ce qu’on sert dans notre stack pour les agents SQL : un alias Qwen3.6 non-thinking, exposant un contrat OpenAI strict (taux de tool-calling à 100 %), avec un template « buun » anti tool-loop et chat_template_kwargs: {enable_thinking: false}. Le mode non-thinking est crucial pour un agent outillé : on veut une décision d’outil immédiate, pas une longue chaîne de raisonnement qui gonfle la latence et risque de boucler. Servir ce modèle en local (sur RTX 3090, vLLM) avec un contrat OpenAI propre permet de brancher n’importe quel harness compatible sans réécrire la couche d’orchestration.

Benchmarks 2026

Les benchmarks d’agents ne mesurent plus la seule qualité du LLM, mais le couple (modèle, harness).

SWE-bench Pro (variante anti-contamination) :

SystèmeScore
Claude Code (Opus)80,8 %
Codex CLI (GPT-5.4-Codex)77,3 %
Aider (DeepSeek V3.2)61,2 %

Terminal-Bench 2.0 (cohérence multi-étapes) : c’est là que l’écart harness se voit le plus — Claude Code ~92,1 %, Codex CLI ~77,3 %, Aider en mode auto ~58 %.

Aider Polyglot (225 exercices Exercism × 6 langages) : sur l’édition de code existant, les outils se tiennent à ±5 % — preuve que pour de l’édition simple, le harness joue moins.

Sur le travail agentique, l’écart entre modèles ouverts et fermés s’est réduit à quelques points : un comparatif indépendant de mi-2026 estimait le retard temporel à environ quatre mois, déjà optimiste à l’échelle de la frontière. Autrement dit, le modèle pèse de moins en moins, le harness de plus en plus — voir Benchmarks LLM pour le détail de cet écart.

Composants clés d’un bon harness

1. Mémoire de projet (CLAUDE.md / AGENTS.md)

Un fichier markdown à la racine du dépôt, chargé automatiquement. Sans lui, l’agent perd 40–60 % de ses appels d’outils en exploration redondante.

# Mon Projet

## Stack
- Backend : FastAPI + PostgreSQL
- Frontend : Next.js, App Router
- Tests : pytest + Playwright

## Commandes
- `make dev` lance les 3 services
- `make test` exécute la suite (~3 min)

## Pièges connus
- Ne pas modifier `legacy/` sans demander
- Le linter est strict (ruff + mypy --strict)

2. Sélection d’outils (tool design)

Trop d’outils confond le LLM ; trop peu le force à improviser. Les harness performants exposent 10–15 outils soigneusement décrits : lecture/écriture fichiers, recherche (Grep, Glob), exécution shell sandboxée, web, sub-agents, gestion de tâches.

3. Gestion du contexte

Fait empirique majeur : au-delà de 50–100K tokens, la précision chute, parfois de 15–20 points. Les bons harness compactent : résumé automatique des vieux tours, repo map plutôt que contenu brut, extraits plutôt que lecture intégrale, sub-agents dont le retour est résumé en 200–400 tokens.

4. Sécurité et permissions

Allow-list de commandes, confirmation utilisateur pour les actions destructives (git push, rm -rf), sandbox (container, VM, worktree git isolé), hooks de validation avant chaque tool call.

Pièges et anti-patterns

  • Trop d’outils (30+) dégradent la qualité du choix.
  • Descriptions d’outils trop courtes → reads explosifs.
  • Pas de mémoire projet → l’agent re-découvre la structure à chaque fois.
  • Boucles infinies : toujours imposer un step budget.
  • Confiance aveugle aux résumés : un sub-agent peut échouer silencieusement → vérifier le diff.
  • Push direct sur main : exiger une confirmation utilisateur.

Tendances 2026

  • Sub-agents standardisés : un harness en invoque facilement un autre.
  • MCP devenu le standard de fait pour brancher des outils tiers.
  • Mémoire long-terme entre conversations.
  • Computer use (vision UI + clics) pour les workflows non-API.
  • Worktrees isolés pour paralléliser sans collision.
  • Hybride local/cloud : routage des tâches simples (Qwen3.6 local) vs complexes (cloud).

Le mot final

En 2026, le harness compte plus que le modèle dans la plupart des tâches d’ingénierie. Investir 30 minutes dans un bon CLAUDE.md rapporte souvent plus que de changer de modèle. À l’inverse, un harness mal configuré annule l’effet d’un bon modèle. Et avec un Qwen3.6-27B quantifié servi en local, on atteint ~80 % des modèles frontières sur l’édition de code — l’écart restant se concentre sur les agents autonomes longs.

Pour aller plus loin

← Toutes les découvertes