Qu'est-ce qu'une Agence d'Agents ?

L'Agence est une collection open-source de 147 agents IA spécialisés pour Claude Code, Cursor, Aider, Windsurf, GitHub Copilot, et bien d'autres. Chaque agent possède une personnalité distincte, des livrables techniques et des métriques de succès. Cette analyse technique approfondie couvre l'architecture des agents, l'intégration multi-outils, la mémoire MCP et les scripts bash qui alimentent le tout.

Vous connaissez probablement la chanson : "Agissez comme un développeur senior" suivi de conseils génériques qui pourraient s'appliquer à n'importe quelle tâche de codage. L'Agence adopte une approche différente. Au lieu d'une seule invite essayant de tout faire, elle propose 147 spécialistes organisés en 12 divisions.

Pensez-y comme à l'assemblage d'une agence à services complets, sauf qu'il s'agit d'agents IA qui ne dorment jamais, ne se plaignent jamais et livrent toujours.

Qu'est-ce que l'Agence ?

La version courte : L'Agence remplace "Agir en tant que développeur" par "Activer le mode Développeur Frontend" — et l'agent Développeur Frontend connaît réellement React, Vue, Angular, Core Web Vitals et la conformité en matière d'accessibilité.

Structure du dépôt : 12 divisions, 147 agents

L'Agence se trouve à l'adresse github.com/msitarzewski/agency-agents. Les agents sont organisés en 12 divisions reflétant l'organigramme d'une agence réelle :

agency-agents/
├── engineering/          # 20+ agents : Frontend, Backend, DevOps, IA, Mobile, Sécurité
├── design/               # 8 agents : Concepteur UI, Chercheur UX, Gardien de Marque, Injecteur de Fantaisie
├── marketing/            # 20+ agents : Growth Hacker, SEO, TikTok, Reddit, LinkedIn
├── sales/                # 8 agents : Coach Découverte, Stratège Commercial, Ingénieur Commercial
├── product/              # 5 agents : Chef de Produit, Chercheur de Tendances, Synthétiseur de Feedback
├── project-management/   # 6 agents : Producteur de Studio, Berger de Projet, Suiveur d'Expériences
├── testing/              # 8 agents : Vérificateur de Réalité, Collecteur de Preuves, Testeur API
├── support/              # 6 agents : Répondant Support, Rapporteur d'Analytiques, Conformité Légale
├── spatial-computing/    # 6 agents : Architecte XR, Ingénieur visionOS, Développeur Metal
├── specialized/          # 30+ agents : Constructeur MCP, Auditeur Blockchain, Auditeur de Conformité
├── game-development/     # 20+ agents : Architecte Unity, Systèmes Unreal, Scripteur Godot, Roblox
└── academic/             # 5 agents : Anthropologue, Historien, Psychologue, Narratologue

Chaque division contient des agents dotés d'une expertise approfondie. La division Ingénierie seule regroupe des développeurs Frontend, des architectes Backend, des automatiseurs DevOps, des ingénieurs de sécurité et même des ingénieurs en firmware embarqué.

Anatomie de l'agent : Au cœur d'un spécialiste de l'IA de 400 lignes

Chaque agent suit la même structure. Voici la répartition en utilisant l'agent Architecte Backend comme exemple :

Frontmatter (YAML)

---
name: Architecte Backend
description: Architecte backend senior spécialisé dans la conception de systèmes évolutifs, l'architecture de bases de données, le développement d'API et l'infrastructure cloud
color: blue
emoji: 🏗️
vibe: Conçoit les systèmes qui soutiennent tout — bases de données, API, cloud, échelle.
---

Ces métadonnées ne sont pas décoratives. Des outils comme Cursor et Claude Code utilisent les champs name et description pour la découverte d'agents. L'emoji fournit une identification visuelle dans les interfaces de chat.

Identité et mémoire

## 🧠 Votre identité et votre mémoire
- **Rôle**: Spécialiste de l'architecture système et du développement côté serveur
- **Personnalité**: Stratégique, axée sur la sécurité, soucieuse de l'évolutivité, obsédée par la fiabilité
- **Mémoire**: Vous vous souvenez des modèles d'architecture réussis, des optimisations de performances et des cadres de sécurité
- **Expérience**: Vous avez vu des systèmes réussir grâce à une architecture appropriée et échouer en raison de raccourcis techniques

Cette section établit la personnalité de l'agent et les limites de son expertise. Ce n'est pas seulement du texte d'ambiance — cela prépare le LLM à adopter un état d'esprit spécifique.

Mission principale

## 🎯 Votre mission principale

### Excellence en ingénierie des données/schémas
- Définir et maintenir les schémas de données et les spécifications d'index
- Concevoir des structures de données efficaces pour des ensembles de données à grande échelle (plus de 100 000 entités)
- Implémenter des pipelines ETL pour la transformation et l'unification des données
- Créer des couches de persistance haute performance avec des temps de requête inférieurs à 20 ms

Chaque élément de mission comprend des objectifs mesurables. Notez « temps de requête inférieurs à 20 ms » et « plus de 100 000 entités » — ce ne sont pas des objectifs vagues.

Règles critiques

## 🚨 Règles critiques que vous devez suivre

### Architecture axée sur la sécurité
- Mettre en œuvre des stratégies de défense en profondeur à travers toutes les couches du système
- Utiliser le principe du moindre privilège pour tous les services et l'accès aux bases de données
- Chiffrer les données au repos et en transit en utilisant les normes de sécurité actuelles

Les règles sont des contraintes non négociables. Elles l'emportent sur le comportement général du LLM.

Livrables techniques

C'est là que les agents se distinguent des invites génériques. L'Architecte Backend fournit un code complet et exécutable :

-- Conception de schéma de base de données e-commerce
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
    deleted_at TIMESTAMP WITH TIME ZONE NULL
);

CREATE INDEX idx_users_email ON users(email) WHERE deleted_at IS NULL;
CREATE INDEX idx_users_created_at ON users(created_at);

// API Express.js avec middleware de sécurité
const helmet = require('helmet');
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 100,
  message: 'Trop de requêtes depuis cette IP, veuillez réessayer plus tard.',
});

Métriques de succès

## 🎯 Vos métriques de succès

Vous réussissez lorsque :
- Les temps de réponse de l'API restent inférieurs à 200 ms pour le 95e percentile
- La disponibilité du système dépasse 99,9 %
- Les requêtes de base de données s'exécutent en moins de 100 ms en moyenne
- Les audits de sécurité ne trouvent aucune vulnérabilité critique

Chaque agent définit des résultats mesurables. Ce n'est pas une affirmation thérapeutique — c'est une responsabilité d'ingénierie.

Intégration multi-outils : un agent, 10 IDE

L'Agence fonctionne avec plus de 10 outils de codage IA. Voici comment fonctionne la couche d'intégration :

Outils supportés

Le script de conversion (convert.sh)

Le script bash scripts/convert.sh gère la traduction de format. Voici l'architecture :

#!/usr/bin/env bash
# convert.sh — Convertir les fichiers .md d'agents d'agence en formats spécifiques aux outils

set -euo pipefail

AGENT_DIRS=(
  academic design engineering game-development marketing paid-media
  sales product project-management testing support spatial-computing specialized
)

# Extraire les champs du frontmatter
get_field() {
  local field="$1" file="$2"
  awk -v f="$field" '
    /^---$/ { fm++; next }
    fm == 1 && $0 ~ "^" f ": " { sub("^" f ": ", ""); print; exit }
  ' "$file"
}

# Supprimer le frontmatter, retourner le corps
get_body() {
  awk 'BEGIN{fm=0} /^---$/{fm++; next} fm>=2{print}' "$1"
}

Pour Cursor, le script convertit les fichiers .md au format de règle .mdc :

convert_cursor() {
  local agent_file="$1"
  local slug=$(to_kebab "$(get_field 'name' "$agent_file")")
  local output_file="$OUT_DIR/cursor/.cursor/rules/agency-${slug}.mdc"

  cat > "$output_file" << EOF
---
description: Agent d'agence : $(get_field 'description' "$agent_file")
---
$(get_body "$agent_file")
EOF
}

Pour Aider et Windsurf, tous les agents sont compilés en fichiers uniques :

convert_aider() {
  local output="$OUT_DIR/aider/CONVENTIONS.md"
  echo "# Agents d'agence pour Aider" > "$output"
  echo "" >> "$output"

  for dir in "${AGENT_DIRS[@]}"; do
    for file in "$REPO_ROOT/$dir"/*.md; do
      echo "---" >> "$output"
      cat "$file" >> "$output"
    done
  done
}

Le script d'installation (install.sh)

Après la conversion, install.sh copie les fichiers dans des répertoires spécifiques aux outils :

#!/usr/bin/env bash
# install.sh — Installer les agents de l'Agence dans vos outils agentiques locaux

install_claude_code() {
  local src="$REPO_ROOT"
  local dest="$HOME/.claude/agents"
  mkdir -p "$dest"
  cp -r "$src"/{engineering,design,marketing,sales,specialized}/*.md "$dest/"
  ok "Claude Code : $(find "$dest" -name '*.md' | wc -l) agents installés"
}

install_cursor() {
  local src="$OUT_DIR/cursor/.cursor/rules"
  local dest="./.cursor/rules"
  mkdir -p "$dest"
  cp "$src"/*.mdc "$dest/"
  ok "Cursor : $(find "$dest" -name '*.mdc' | wc -l) règles installées"
}

Le script prend en charge la sélection interactive :

  +------------------------------------------------+
  |   L'Agence — Installateur d'outils             |
  +------------------------------------------------+

  Analyse du système : [*] = détecté sur cette machine

  [x]  1)  [*]  Claude Code     (claude.ai/code)
  [x]  2)  [*]  Copilot         (~/.github + ~/.copilot)
  [x]  3)  [*]  Antigravity     (~/.gemini/antigravity)
  [ ]  4)  [ ]  Gemini CLI      (extension gemini)
  [x]  7)  [*]  Curseur         (.cursor/rules)

  [1-10] basculer   [a] tout   [n] aucun   [d] détecté
  [Entrée] installer   [q] quitter

L'exécution parallèle accélère les installations multi-outils :

./scripts/install.sh --parallel --jobs 8

Mémoire MCP : contexte persistant entre les sessions

Par défaut, les agents IA démarrent chaque session à partir de zéro. L'intégration de la Mémoire MCP change cela.

Qu'est-ce que MCP ?

MCP (Model Context Protocol) est un protocole permettant aux agents IA d'accéder à des outils externes et à un stockage persistant. L'Agence utilise MCP pour permettre :

• Mémoire inter-sessions : Les agents se souviennent des décisions des sessions précédentes
• Passage de main entre agents : Un agent peut laisser du contexte pour un autre
• Restauration en cas d'échec : Revenir à des états connus et fonctionnels en cas d'échec de l'assurance qualité

Le modèle de mémoire

Ajoutez cette section à n'importe quel agent pour activer la mémoire MCP :

## Intégration de la mémoire

Lorsque vous démarrez une session :
- Rappelez le contexte pertinent des sessions précédentes en utilisant votre rôle et le projet comme termes de recherche
- Passez en revue toutes les mémoires étiquetées avec le nom de votre agent

Lorsque vous prenez des décisions clés ou achevez des livrables :
- Mémorisez la décision avec des étiquettes descriptives (nom de l'agent, projet, sujet)
- Incluez suffisamment de contexte pour qu'une future session puisse comprendre ce qui a été fait et pourquoi

Lorsque vous transférez à un autre agent :
- Mémorisez vos livrables étiquetés pour l'agent destinataire
- Incluez : ce que vous avez accompli, ce qui est en attente, ce que le prochain agent doit savoir

Outils MCP

Tout serveur MCP exposant ces outils fonctionne :

Exemple : flux de travail alimenté par la mémoire

Sans mémoire MCP :

Utilisateur : "Construis l'API"
Agent : [Construit l'API, la session se termine]

[Session suivante]
Utilisateur : "Continuer à partir d'hier"
Agent : "Je n'ai pas de contexte des sessions précédentes. Pouvez-vous copier ce que nous avons fait ?"

Avec la mémoire MCP :

Utilisateur : "Construis l'API"
Agent : [Construit l'API, mémorise : "Architecte Backend - API E-commerce - Table utilisateurs, authentification JWT, limitation de débit"]

[Session suivante]
Utilisateur : "Continuer à partir d'hier"
Agent : [Rappelle : "Hier, j'ai conçu la table des utilisateurs avec des clés primaires UUID, implémenté l'authentification JWT avec hachage bcrypt, et ajouté une limitation de débit à 100 requêtes par 15 minutes. Prochaine étape : schéma du Service de Commande."]

Voir integrations/mcp-memory/backend-architect-with-memory.md pour un exemple complet.

Agents remarquables : Trois analyses approfondies

1. Vérificateur de Réalité (Division Test)

Le Vérificateur de Réalité met fin aux approbations fantaisistes. Position par défaut : « NÉCESSITE DU TRAVAIL » jusqu'à preuve du contraire.

## 🚨 Votre processus obligatoire

### ÉTAPE 1 : Commandes de vérification de la réalité (À NE JAMAIS SAUTER)
```bash
# Vérifier ce qui a réellement été construit
ls -la resources/views/ || ls -la *.html

# Vérifier les fonctionnalités revendiquées
grep -r "luxury\|premium\|glass\|morphism" . --include="*.html" --include="*.css" || echo "AUCUNE FONCTIONNALITÉ PREMIUM TROUVÉE"

# Exécuter la capture d'écran professionnelle Playwright
./qa-playwright-capture.sh http://localhost:8000 public/qa-screenshots

ÉTAPE 2 : Validation croisée QA

• Examiner les conclusions de l'agent QA issues des tests Chrome headless
• Comparer les captures d'écran automatisées avec l'évaluation de l'AQ
• Confirmer ou contester l'évaluation de l'AQ avec des preuves supplémentaires

ÉTAPE 3 : Validation de bout en bout

• Analyser responsive-desktop.png, responsive-tablet.png, responsive-mobile.png
• Vérifier les flux d'interaction : séquences nav--click.png, form-.png
• Examiner les données de performance réelles (temps de chargement, erreurs, métriques)

Cet agent exige une **preuve visuelle** avant d'approuver quoi que ce soit. Plus de "Ça a l'air super !" sans preuve.

---

### 2. Injecteur de Fantaisie (Division Design)

L'Injecteur de Fantaisie ajoute de la personnalité sans sacrifier l'utilisabilité.

```css
/* Interactions de bouton délicieuses */
.btn-whimsy {
  position: relative;
  overflow: hidden;
  transition: all 0.3s cubic-bezier(0.23, 1, 0.32, 1);

  &::before {
    content: '';
    position: absolute;
    top: 0;
    left: -100%;
    width: 100%;
    height: 100%;
    background: linear-gradient(90deg, transparent, rgba(255, 255, 255, 0.2), transparent);
    transition: left 0.5s;
  }

  &:hover {
    transform: translateY(-2px) scale(1.02);
    box-shadow: 0 8px 25px rgba(0, 0, 0, 0.15);
  }
}

// Système de succès avec fantaisie
class WhimsyAchievements {
  unlock(achievementId) {
    const achievement = this.achievements[achievementId];
    this.showCelebration(achievement);
    this.saveProgress(achievementId);
  }

  showCelebration(achievement) {
    const celebration = document.createElement('div');
    celebration.className = `achievement-celebration ${achievement.celebration}`;
    celebration.innerHTML = `
      <div class="achievement-card">
        <div class="achievement-icon">${achievement.icon}</div>
        <h3>${achievement.title}</h3>
        <p>${achievement.description}</p>
      </div>
    `;
    document.body.appendChild(celebration);
    setTimeout(() => celebration.remove(), 3000);
  }
}

Chaque élément ludique doit servir un objectif fonctionnel ou émotionnel. L'agent inclut une bibliothèque complète de microcopy :

## Messages d'erreur
**Page 404** : "Oups ! Cette page est partie en vacances sans nous le dire."
**Validation de formulaire** : "Votre e-mail semble un peu timide – ça vous dérange d'ajouter le symbole @ ?"
**Erreur réseau** : "Il semble qu'internet ait eu un hoquet. Essayez à nouveau ?"

3. Constructeur MCP (Division Spécialisée)

Le Constructeur MCP crée des outils personnalisés qui étendent les capacités des agents IA.

// Squelette de serveur MCP TypeScript
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-server", version: "1.0.0" });

server.tool("search_items", { query: z.string(), limit: z.number().optional() },
  async ({ query, limit = 10 }) => {
    const results = await searchDatabase(query, limit);
    return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Règles critiques :

• Noms d'outils descriptifs : search_users et non query1 — les agents choisissent les outils par leur nom
• Paramètres typés avec Zod : Chaque entrée est validée, les paramètres optionnels ont des valeurs par défaut
• Sortie structurée : Retourner du JSON pour les données, du Markdown pour le contenu lisible par l'homme
• Gérer les échecs avec élégance : Retourner des messages d'erreur, ne jamais faire planter le serveur

Communauté et traductions

L'Agence a commencé par un fil Reddit. Aujourd'hui, elle compte :

• 147 agents répartis en 12 divisions
• Plus de 10 000 lignes de personnalité, de processus et d'exemples de code
• Traductions communautaires : Chinois simplifié (deux forks indépendants), d'autres en cours
• Support multi-outils : Plus de 10 intégrations maintenues via des scripts de conversion

Forks notables :

• agency-agents-zh par @jnMetaCode : 100 agents traduits + 9 originaux pour le marché chinois
• agent-teams par @dsclca12 : Traduction indépendante avec localisation pour Bilibili, WeChat, Xiaohongshu

Installation : Démarrage rapide

Option 1 : Claude Code (Recommandé)

# Copiez les agents dans votre répertoire Claude Code
cp -r agency-agents/* ~/.claude/agents/

# Activez dans n'importe quelle session :
"Hé Claude, active le mode Développeur Frontend et aide-moi à construire un composant React"

Option 2 : Installation multi-outils

# Étape 1 : Générer les fichiers d'intégration
./scripts/convert.sh

# Étape 2 : Installer interactivement (détecte automatiquement les outils)
./scripts/install.sh

# Ou installer un outil spécifique directement
./scripts/install.sh --tool cursor
./scripts/install.sh --tool aider

Option 3 : Utiliser comme référence

Parcourez les agents sur github.com/msitarzewski/agency-agents et adaptez ceux dont vous avez besoin. Chaque fichier contient l'identité, les flux de travail, les livrables et des exemples de code.

Qu'est-ce qui rend cela différent ?

Comparé aux invites IA génériques

Comparé aux bibliothèques d'invites

Comparé aux outils IA

Points techniques à retenir

1. La spécialisation l'emporte sur la généralisation : 147 spécialistes surpassent une invite "tout-en-un"
2. La structure détermine la production : Frontmatter + Identité + Mission + Règles + Livrables + Métriques
3. L'intégration est essentielle : Les scripts Bash convertissent automatiquement les agents dans plus de 10 formats
4. La mémoire assure la continuité : Le protocole MCP résout le problème du "Je ne me souviens pas d'hier"
5. La communauté évolue : Fil Reddit → 147 agents → traductions → support multi-outils

Prochaines étapes

Envie d'essayer l'Agence ?

1. Parcourez la liste complète des agents
2. Installez-la pour votre outil préféré (Claude Code, Cursor, Aider, etc.)
3. Activez les spécialistes par leur nom : "Utilisez le Vérificateur de Réalité pour vérifier que ceci est prêt pour la production"
4. Contribuez : Ajoutez de nouveaux agents, améliorez les existants, partagez des réussites

Vous construisez vous-même des agents IA ? Étudiez l'anatomie des agents : le frontmatter pour la découverte, l'identité pour la personnalité, la mission pour la portée, les règles pour les contraintes, les livrables pour la sortie, les métriques pour la responsabilité.

L'Agence prouve que la spécialisation n'est pas réservée aux humains. Parfois, la meilleure équipe d'IA n'est pas un modèle essayant de tout faire — ce sont 147 spécialistes qui savent exactement ce qu'ils sont censés faire.