On parle partout d'agents IA, de MCP, de skills, de rules... Mais concrètement, qu'est-ce que tout ça veut dire ? Cet article démystifie le vocabulaire de l'IA agentique, montre comment utiliser les agents au quotidien, et explique comment en créer soi-même avec le Claude Agent SDK.
Avant de plonger dans la pratique, posons les bases. Quatre termes reviennent en boucle quand on parle de Claude Code : agents, MCP servers, skills et rules. Ils ne font pas du tout la même chose.
Analogie : Les rules, c'est comme le règlement intérieur d'une entreprise. Elles définissent ce que l'IA doit toujours faire (ou ne jamais faire), quel que soit le contexte.
Les rules sont des instructions permanentes que Claude suit à chaque conversation. Elles ne sont pas déclenchées manuellement : elles sont toujours actives, en arrière-plan.
Exemple concret : Vous travaillez sur un projet Python et vous voulez que Claude respecte vos conventions.
# Fichier : CLAUDE.md (à la racine du projet)
## Conventions
- Toujours écrire le code en français (variables, commentaires)
- Utiliser des f-strings, jamais .format()
- Les tests doivent utiliser pytest, pas unittest
- Ne jamais committer de fichiers .env
- Utiliser des type hints sur toutes les fonctionsCes règles s'appliquent automatiquement à chaque interaction. Vous n'avez pas besoin de les rappeler. Claude les lit au début de chaque conversation et les respecte.
Trois niveaux de rules existent :
~/.claude/CLAUDE.md) : s'appliquent à tous vos projets./CLAUDE.md à la racine) : s'appliquent à un dépôt spécifique./src/api/CLAUDE.md) : s'appliquent uniquement dans ce dossierAnalogie : Un skill, c'est comme une recette de cuisine. Vous l'écrivez une fois, et chaque fois que vous dites « fais-moi une quiche », l'IA suit les étapes sans que vous ayez à tout ré-expliquer.
Un skill est un fichier Markdown contenant des instructions détaillées, que vous déclenchez avec une commande /nom-du-skill.
Exemple concret : Un skill pour générer des descriptions YouTube.
# Fichier : ~/.claude/skills/descyt/SKILL.md
---
name: descyt
description: Génère une description YouTube formatée
allowed-tools: Read, Grep
---
Quand on me demande de générer une description YouTube :
1. Lire le contenu de la vidéo ou les notes fournies
2. Structurer la description avec :
- Un résumé accrocheur (2-3 lignes)
- Les timestamps des moments clés
- Les liens vers les ressources mentionnées
- Les tags pertinents
3. Adapter le ton à la chaîne (gaming, tech, tuto...)Usage : Tapez /descyt dans Claude Code, et l'IA génère la description en suivant exactement vos instructions.
Analogie : Un MCP server, c'est comme une prise USB. Il permet à Claude de se « brancher » sur un outil externe (GitHub, une base de données, Google Calendar...) pour lire et écrire des données.
Le Model Context Protocol (MCP) est un standard ouvert créé par Anthropic. Il définit comment un modèle de langage peut interagir avec des outils externes de manière standardisée.
Exemple concret : Connecter Claude à GitHub.
# Ajouter le serveur MCP GitHub
claude mcp add --scope user --transport http github https://api.github.com/mcp/
# Maintenant, Claude peut :
# - Lire vos issues et pull requests
# - Créer des PR automatiquement
# - Commenter du code sur GitHub
# - Chercher dans vos dépôtsSans MCP, Claude est enfermé dans votre terminal. Avec MCP, il accède à tout votre écosystème d'outils.
Analogie : Un agent, c'est un stagiaire ultra-compétent. Vous lui donnez une mission (« corrige ce bug »), et il se débrouille tout seul : il lit le code, identifie le problème, propose une solution, la teste, et vous rend le travail fini.
Un agent est un programme autonome piloté par un LLM qui peut prendre des décisions, utiliser des outils, et enchaîner des actions pour atteindre un objectif. La différence fondamentale avec un simple chatbot : l'agent agit, il ne se contente pas de répondre.
| Concept | Rôle | Quand ça s'active | Exemple simple |
|---|---|---|---|
| Rules | Définir le cadre | Toujours (automatique) | « Écris toujours en français » |
| Skills | Automatiser une tâche | Sur commande (/skill) |
« Génère une description YouTube » |
| MCP Servers | Connecter à un outil | Quand l'agent en a besoin | « Lis mes issues GitHub » |
| Agents | Agir de manière autonome | Quand une mission est donnée | « Corrige ce bug tout seul » |
Pour résumer en une phrase : Les rules disent comment se comporter, les skills disent quoi faire sur commande, les MCP servers donnent accès aux outils, et les agents combinent tout ça pour agir de manière autonome.
Maintenant que le vocabulaire est clair, voyons comment les agents fonctionnent en pratique avec Claude Opus 4.6.
Dans Claude Code, vous pouvez lancer des subagents : des agents spécialisés qui travaillent en parallèle de votre conversation principale. Chaque subagent a son propre contexte et ses propres outils.
Exemple : Vous êtes en train de coder une API et vous trouvez un bug dans un autre fichier.
# Vous dites simplement à Claude :
"Lance un agent en arrière-plan pour corriger le bug
dans auth.py pendant que je continue sur l'API"
# Claude crée un subagent qui :
# 1. Lit auth.py et les fichiers liés
# 2. Identifie le problème
# 3. Propose et applique un correctif
# 4. Lance les tests
# 5. Vous notifie quand c'est faitPendant ce temps, vous continuez à travailler normalement. C'est du multitâche IA.
Avec Claude Opus 4.6, vous pouvez créer des agents qui s'exécutent automatiquement sur un planning, comme des cron jobs intelligents.
# Créer un agent de veille qui tourne tous les matins à 8h
claude schedule create \
--name "veille-securite" \
--cron "0 8 * * *" \
--prompt "Vérifie les CVE publiées hier qui concernent
nos dépendances npm. Résume-les par criticité."Cas d'usage courants :
Claude Code fonctionne partout : en CLI dans le terminal, dans VSCode, dans JetBrains, et même en version web sur claude.ai/code.
Idéal pour les tâches lourdes : migrations, refactoring massif, analyse de gros projets. L'agent a accès à tout votre système de fichiers.
claude "Migre toutes les
requêtes SQL raw vers
l'ORM Prisma"Idéal pour le quotidien : l'agent voit votre fichier ouvert, votre sélection, vos erreurs en temps réel. Intégration fluide.
# Sélectionnez du code
# Ctrl+L pour ouvrir Claude
# "Refactorise cette
# fonction"Voici un scénario réaliste qui combine rules, skills, MCP et agents :
Contexte : Vous recevez un ticket Jira « Ajouter la pagination sur l'endpoint /api/users ».
# 1. Les RULES sont déjà en place (CLAUDE.md)
# → Claude sait qu'il faut utiliser TypeScript, Prisma, et écrire les tests
# 2. Vous lancez Claude avec le ticket
claude "Implémente le ticket PROJ-456 : pagination sur /api/users"
# 3. Claude utilise le MCP GitHub pour lire le ticket
# → Il comprend les critères d'acceptation
# 4. Claude lance plusieurs SUBAGENTS en parallèle :
# - Agent 1 : Modifie le contrôleur API
# - Agent 2 : Met à jour la requête Prisma
# - Agent 3 : Écrit les tests
# 5. Une fois le code prêt, vous lancez un SKILL
# /commit → Message de commit propre + PR créée automatiquementTout l'écosystème travaille ensemble : les rules définissent le cadre, le MCP connecte aux outils, les agents codent, et le skill finalise.
Ce qui change avec Opus 4.6 : Les agents sont plus fiables, suivent mieux les instructions complexes, font moins d'erreurs sur du code long, et gèrent mieux les projets avec beaucoup de fichiers. La fenêtre de contexte élargie permet de travailler sur des bases de code plus grandes sans perdre le fil.
On entre dans la partie technique. Si vous voulez aller au-delà de Claude Code et construire vos propres agents programmables, Anthropic fournit le Claude Agent SDK.
Un agent repose sur une boucle simple :
boucle agent:
1. Recevoir une entrée (message utilisateur, résultat d'outil...)
2. Réfléchir (le LLM analyse et décide quoi faire)
3. Agir (appeler un outil, écrire du code, lire un fichier...)
4. Observer le résultat
5. Recommencer jusqu'à ce que la tâche soit terminéeC'est ce qu'on appelle la boucle ReAct (Reasoning + Acting). Le LLM ne fait pas qu'une seule prédiction : il enchaîne les étapes de réflexion et d'action jusqu'à résoudre le problème.
Voici les composants essentiels :
Claude Opus 4.6, Sonnet 4.6 ou Haiku 4.5. C'est lui qui raisonne, planifie et prend les décisions. Le choix du modèle dépend du compromis vitesse/intelligence.
Les actions que l'agent peut effectuer : lire un fichier, exécuter une commande, appeler une API, chercher sur le web... Sans outils, l'agent ne peut que parler.
Les instructions initiales qui définissent le comportement de l'agent : son rôle, ses contraintes, son style. C'est l'équivalent des « rules » mais codées en dur.
L'historique de la conversation et les résultats des actions passées. Permet à l'agent de garder le contexte et d'apprendre de ses erreurs au fil de la session.
Le Claude Agent SDK simplifie énormément la création d'agents. Voici un exemple concret : un agent qui analyse des fichiers de logs pour trouver des anomalies.
1 Installation
pip install claude-agent-sdk2 Définir les outils de l'agent
import anthropic
from pathlib import Path
# Créer le client Anthropic
client = anthropic.Anthropic()
# Définir un outil pour lire des fichiers
tools = [
{
"name": "lire_fichier",
"description": "Lit le contenu d'un fichier sur le disque",
"input_schema": {
"type": "object",
"properties": {
"chemin": {
"type": "string",
"description": "Le chemin du fichier à lire"
}
},
"required": ["chemin"]
}
},
{
"name": "chercher_pattern",
"description": "Cherche un pattern regex dans un texte",
"input_schema": {
"type": "object",
"properties": {
"texte": {
"type": "string",
"description": "Le texte dans lequel chercher"
},
"pattern": {
"type": "string",
"description": "Le pattern regex à chercher"
}
},
"required": ["texte", "pattern"]
}
}
]3 Implémenter l'exécution des outils
import re
def executer_outil(nom, parametres):
"""Exécute un outil et retourne le résultat."""
if nom == "lire_fichier":
chemin = Path(parametres["chemin"])
if chemin.exists():
return chemin.read_text(encoding="utf-8")
return f"Erreur : le fichier {chemin} n'existe pas"
elif nom == "chercher_pattern":
resultats = re.findall(
parametres["pattern"],
parametres["texte"]
)
if resultats:
return f"Trouvé {len(resultats)} correspondances : "
+ "\n".join(resultats[:20])
return "Aucune correspondance trouvée"
return f"Outil inconnu : {nom}"4 La boucle agentique
def agent_analyse_logs(mission: str):
"""Agent autonome qui analyse des logs."""
# Historique de la conversation
messages = [{"role": "user", "content": mission}]
prompt_systeme = """Tu es un expert en analyse de logs.
Ta mission : analyser les fichiers de logs fournis,
identifier les anomalies (erreurs, pics de latence,
patterns suspects) et produire un rapport clair.
Procède étape par étape :
1. Lis les fichiers de logs
2. Cherche les patterns d'erreur (ERROR, WARN, Exception)
3. Identifie les tendances anormales
4. Produis un rapport structuré avec tes trouvailles"""
print(f"Agent lancé avec la mission : {mission}\n")
# Boucle ReAct
while True:
# Le LLM réfléchit et décide
reponse = client.messages.create(
model="claude-sonnet-4-6-20250415",
max_tokens=4096,
system=prompt_systeme,
tools=tools,
messages=messages
)
# Si l'agent a fini (pas d'appel d'outil)
if reponse.stop_reason == "end_turn":
# Extraire la réponse finale
texte_final = ""
for bloc in reponse.content:
if bloc.type == "text":
texte_final += bloc.text
print("--- Rapport de l'agent ---")
print(texte_final)
return texte_final
# Sinon, exécuter les outils demandés
messages.append({
"role": "assistant",
"content": reponse.content
})
resultats_outils = []
for bloc in reponse.content:
if bloc.type == "tool_use":
print(f" Outil : {bloc.name}({bloc.input})")
resultat = executer_outil(bloc.name, bloc.input)
resultats_outils.append({
"type": "tool_result",
"tool_use_id": bloc.id,
"content": resultat
})
messages.append({
"role": "user",
"content": resultats_outils
})
# Lancer l'agent
agent_analyse_logs(
"Analyse les logs dans /var/log/app/ et trouve "
"les anomalies des dernières 24h"
)Pour des tâches complexes, vous pouvez créer un agent orchestrateur qui délègue à des sous-agents spécialisés.
def agent_orchestrateur(mission: str):
"""Agent principal qui coordonne des sous-agents."""
# L'orchestrateur a un outil spécial : lancer un sous-agent
outils_orchestrateur = [
{
"name": "deleguer",
"description": "Délègue une sous-tâche à un agent spécialisé",
"input_schema": {
"type": "object",
"properties": {
"role": {
"type": "string",
"enum": ["analyste", "correcteur", "testeur"],
"description": "Le rôle du sous-agent"
},
"tache": {
"type": "string",
"description": "La tâche à accomplir"
}
},
"required": ["role", "tache"]
}
}
]
prompts_par_role = {
"analyste": "Tu analyses le code et identifies les problèmes.",
"correcteur": "Tu corriges les bugs identifiés.",
"testeur": "Tu écris et exécutes des tests."
}
# Quand l'orchestrateur appelle "deleguer" :
# → On lance un nouvel agent avec le bon prompt système
# → Le sous-agent travaille de manière autonome
# → Son résultat est renvoyé à l'orchestrateur
# → L'orchestrateur décide de la suiteCe pattern d'orchestration est exactement ce que fait Claude Code en interne quand il lance des subagents.
Attention : Un agent mal conçu peut tourner en boucle, consommer des tokens inutilement, ou pire, exécuter des actions destructrices. Voici les règles essentielles.
MAX_ITERATIONS = 20
for i in range(MAX_ITERATIONS):
reponse = client.messages.create(...)
if reponse.stop_reason == "end_turn":
break
else:
print("Agent arrêté : limite atteinte")def executer_outil_securise(nom, params):
actions_sensibles = ["supprimer", "envoyer_mail", "git_push"]
if nom in actions_sensibles:
print(f"L'agent veut exécuter : {nom}({params})")
if input("Autoriser ? (o/n) ") != "o":
return "Action refusée par l'utilisateur"
return executer_outil(nom, params)Vos agents personnalisés peuvent aussi utiliser MCP pour se connecter à des outils externes. Le SDK gère la connexion aux serveurs MCP de manière transparente.
# Exemple : agent avec accès à une base de données via MCP
from claude_agent_sdk import Agent, MCPServer
agent = Agent(
model="claude-sonnet-4-6-20250415",
system="Tu es un analyste de données. Utilise la base "
"de données pour répondre aux questions.",
mcp_servers=[
MCPServer(
name="postgres",
command="npx",
args=["@mcp/server-postgres"],
env={"DATABASE_URL": "postgresql://..."}
)
]
)
# L'agent peut maintenant exécuter des requêtes SQL
# via le serveur MCP PostgreSQL
resultat = agent.run(
"Quels sont les 10 utilisateurs les plus actifs ce mois-ci ?"
)Ce qu'il faut retenir : Un agent, c'est une boucle LLM + outils. Le Claude Agent SDK vous évite de réinventer cette boucle. Les MCP servers vous évitent de réinventer les connecteurs. Concentrez-vous sur la logique métier de votre agent, pas sur la plomberie.
Conclusion
L'IA agentique n'est pas un buzzword. C'est une évolution concrète dans la façon dont on interagit avec les modèles de langage. Avec Claude Opus 4.6, les rules posent le cadre, les skills automatisent les tâches répétitives, les MCP servers connectent l'IA à vos outils, et les agents combinent tout ça pour travailler de manière autonome.
Le plus intéressant : vous n'avez pas besoin d'être expert pour commencer. Un fichier CLAUDE.md et quelques skills suffisent pour transformer votre workflow. Et quand vous serez prêt, le SDK est là pour construire des agents sur mesure.
Vous avez testé les agents avec Claude ? Partagez votre expérience :
LinkedIn GitHubArticle rédigé avec l'aide de Claude Opus 4.6 · Avril 2026
Vous avez aimé cet article ?
Voir tous mes articles