- Remplacer les appels d’outils par du code réduit tes coûts de 98% – et évite de saturer le contexte du modèle avec des centaines de définitions inutiles.
- Le Model Context Protocol (MCP) a révolutionné les workflows multi-outils, mais a révélé un écueil majeur : les définitions d’outils et les données intermédiaires dévorent ton budget tokens et ralentissent tes agents.
- L’exécution de code dans un runtime sandboxé résout ce casse-tête en offrant :
- Une découverte progressive des outils (plus de 100k tokens engloutis en une fois)
- Un filtrage intelligent des données (5 lignes au lieu de 10 000)
- Des boucles et logiques déterministes (sans solliciter le LLM)
- Une gestion sécurisée des données sensibles (tokenisation automatique)
—
Agents IA : Pourquoi tes workflows coûtent une fortune (et comment y remédier)
Tu as déjà connecté un agent IA à Google Drive, Salesforce ou Slack ? Si c’est le cas, tu as probablement vécu ce cauchemar :
- Des latences dignes d’un escargot sous sédatifs (le modèle digère 100k tokens avant même de commencer à travailler)
- Une facture tokens qui explose (150k tokens pour un simple transfert de transcription ? Vraiment ?)
- Des erreurs à répétition (JSON corrompus, caractères perdus, données sensibles exposées comme des secrets d’État)
Le Model Context Protocol (MCP), lancé fin 2024, a tout changé. En quelques mois, des milliers de MCP servers ont émergé. Les SDKs sont disponibles dans tous les langages. Les développeurs connectent désormais leurs agents à des centaines d’outils en un clin d’œil.
Sauf que… ça ne scale pas. Et personne ne t’a prévenu.
—
Le problème : MCP a créé un monstre (et tu en paies le prix)
1. Les définitions d’outils : un gouffre à tokens
La plupart des implémentations chargent toutes les définitions d’outils dans le contexte du modèle avant même de traiter ta requête. Un vrai gaspillage.
Prenons cet exemple :
gdrive.getDocument
Description: Récupère un document depuis Google Drive
Parameters:
documentId (required, string): L'ID du document
Returns: Document avec titre, contenu, métadonnées, permissions...Multiplie ça par 100 outils → 100k tokens avalés avant même que le modèle ne commence à travailler.
Conséquences :
- Coût prohibitif (100k tokens = ~100$ pour un workflow basique)
- Latence monstrueuse (le modèle doit ingurgiter des pages de documentation avant de répondre)
- Fragilité accrue (le contexte saturé multiplie les erreurs)
2. Les données intermédiaires : un aller-retour coûteux
Imaginons un workflow simple :
« Récupère la transcription de ma réunion depuis Google Drive et charge-la dans Salesforce. »
Avec une approche classique, voici ce qui se passe :
- TOOL CALL :
gdrive.getDocument(documentId: "abc123")
→ Retourne une transcription de 50k tokens (2h de réunion) → Chargée dans le contexte du modèle
- TOOL CALL :
salesforce.updateRecord()
→ Le modèle réécrit les 50k tokens dans le contexte pour les envoyer à Salesforce
Problème :
- Coût doublé (les 50k tokens passent deux fois par le modèle)
- Fragilité (le modèle peut corrompre le JSON ou perdre des données)
- Exposition des données sensibles (la transcription complète est visible par le modèle)
—
La solution : Exécuter du code plutôt que des appels d’outils
La révolution ? Ne plus faire transiter outils et données par le modèle.
À la place :
- Définis tes outils sous forme de fichiers de code (TypeScript, Python, etc.)
- Laisse l’agent exécuter ce code dans un runtime sandboxé
- Ne transmets au modèle que l’essentiel (résumés, logs, ou données filtrées)
Exemple concret : Transférer une transcription de Google Drive à Salesforce
Avant (coûteux et fragile)
// 150k tokens consommés pour un workflow simple
TOOL CALL: gdrive.getDocument(documentId: "abc123")
→ Retourne la transcription complète (50k tokens)
TOOL CALL: salesforce.updateRecord(
objectType: "SalesMeeting",
recordId: "00Q5f000001abcXYZ",
data: { Notes: "[transcription complète]" } // 50k tokens réécrits
)Après (optimisé et sécurisé)
// 2k tokens consommés (réduction de 98%)
import * as gdrive from './servers/google-drive';
import * as salesforce from './servers/salesforce';
const transcript = (await gdrive.getDocument({ documentId: 'abc123' })).content;
await salesforce.updateRecord({
objectType: 'SalesMeeting',
recordId: '00Q5f000001abcXYZ',
data: { Notes: transcript } // Seul le résultat est transmis au modèle
});—
Pourquoi ça change tout ? 5 avantages clés
1. Découverte progressive des outils (adieu les 100k tokens avalés d’un coup)
Avec l’exécution de code, l’agent ne charge que les outils dont il a besoin.
Exemple :
// L'agent explore le système de fichiers pour découvrir les outils disponibles
const servers = await fs.readdir("./servers");
// ["google-drive", "salesforce", "slack"]
// Il ne charge que les outils nécessaires
const gdriveTools = await import("./servers/google-drive/index.ts");Résultat :
- Plus de contexte saturé (seuls les outils utilisés sont chargés)
- Coûts réduits (pas de tokens gaspillés sur des outils inutiles)
- Scalabilité illimitée (centaines d’outils sans problème)
2. Filtrage des données avant envoi au modèle
Imaginons que tu veuilles analyser un tableau Google Sheets de 10 000 lignes.
Avant (coûteux et inefficace)
TOOL CALL: gdrive.getSheet(sheetId: "abc123")
→ Retourne 10 000 lignes (50k tokens) chargées dans le contexteAprès (optimisé et intelligent)
const allRows = await gdrive.getSheet({ sheetId: 'abc123' });
const pendingRows = allRows.filter(row => row.Status === "pending").slice(0, 5);
console.log(pendingRows); // Seules 5 lignes sont transmises au modèleRésultat :
- 99% de tokens économisés (seules les données pertinentes sont envoyées)
- Latence réduite (le modèle ne traite que l’essentiel)
- Fiabilité accrue (moins de risques de corruption de données)
3. Logique déterministe (sans passer par le modèle)
Besoin de surveiller un canal Slack jusqu’à ce qu’un message spécifique apparaisse ?
Avant (lent et coûteux)
// Le modèle gère la boucle via des prompts
let ready = false;
while (!ready) {
const msgs = TOOL CALL: slack.getChannelHistory(channel: "C123456");
ready = msgs.some(msg => msg.text.includes("deployment complete"));
// Attente + réexécution du prompt = coûteux et lent
}Après (rapide et déterministe)
// Le code s'exécute dans le runtime, sans solliciter le modèle
let ready = false;
while (!ready) {
const msgs = await slack.getChannelHistory({ channel: 'C123456' });
ready = msgs.some(m => m.text.includes('deployment complete'));
if (!ready) await new Promise(r => setTimeout(r, 5000));
}
console.log("Déploiement terminé !");Résultat :
- Coût réduit à zéro (la boucle ne consomme pas de tokens)
- Latence quasi nulle (exécution déterministe dans le runtime)
- Fiabilité maximale (pas de risques d’erreurs liées au modèle)
4. Gestion sécurisée des données sensibles
Besoin de mettre à jour des leads depuis un tableau contenant des emails et numéros de téléphone ?
Avant (risqué)
// Les données sensibles sont exposées au modèle
TOOL CALL: salesforce.updateRecord(
objectType: "Lead",
recordId: "00Q5f000001abcXYZ",
data: {
Email: "user@example.com", // Donnée sensible exposée
Phone: "+1234567890" // Donnée sensible exposée
}
)Après (sécurisé)
// Tokenisation automatique des données sensibles
for (const row of sheet.rows) {
await salesforce.updateRecord({
objectType: "Lead",
recordId: row.salesforceId,
data: {
Email: "[EMAIL_TOKENIZED]", // Donnée masquée pour le modèle
Phone: "[PHONE_TOKENIZED]" // Donnée masquée pour le modèle
}
});
}Résultat :
- Données sensibles protégées (tokenisation automatique)
- Conformité RGPD/GDPR (pas de fuite de PII)
- Déterminisme (les règles de sécurité sont appliquées en amont)
5. Persistance et réutilisabilité (des agents qui s’améliorent tout seuls)
Avec l’exécution de code, les agents peuvent :
- Stocker des données (fichiers CSV, logs, etc.)
- Créer des compétences réutilisables (sauvegarder des workflows sous forme de fonctions)
- S’auto-améliorer (en documentant leurs compétences via des fichiers
SKILL.md)
Exemple :
// Sauvegarder un tableau en CSV pour réutilisation ultérieure
export async function saveSheetAsCsv(sheetId: string) {
const data = await gdrive.getSheet({ sheetId });
const csv = data.map(row => row.join(',')).join('n');
await fs.writeFile(`./workspace/sheet-${sheetId}.csv`, csv);
}
// Documenter la compétence pour réutilisation
// ./servers/google-drive/SKILL.md
# saveSheetAsCsv
Sauvegarde un tableau Google Sheets en CSV pour analyse ultérieure.Résultat :
- Autonomie accrue (l’agent construit ses propres outils)
- Réutilisabilité (les compétences sont documentées et partagées)
- Évolutivité (l’agent s’améliore avec le temps)
—
Le trade-off : Un runtime sandboxé est indispensable
L’exécution de code dans un agent IA n’est pas sans risques :
- Exécution de code malveillant (injection, attaques)
- Accès non contrôlé au système de fichiers (fuites de données)
- Boucles infinies (latence, crash)
- Consommation excessive de ressources (RAM, CPU)
Solutions :
- Sandboxing strict (limites de temps d’exécution, restrictions de fichiers)
- Monitoring en temps réel (détection des comportements anormaux)
- Tokenisation automatique (protection des données sensibles)
Exemple de runtime sécurisé :
// Configuration d'un runtime sandboxé
const runtime = new AgentRuntime({
timeout: 5000, // Limite de temps d'exécution
fs: { // Restrictions de système de fichiers
allowedPaths: ["./servers", "./workspace"],
forbiddenPaths: ["/etc", "/var"]
},
memoryLimit: "128MB" // Limite de mémoire
});—
Comment démarrer ? 4 étapes concrètes
1. Identifie tes workflows les plus coûteux
Commence par migrer les workflows qui :
- Consomment le plus de tokens (transcriptions, tableaux, logs)
- Utilisent le plus d’outils (centaines de définitions dans le contexte)
- Traîtent des données sensibles (emails, numéros de téléphone)
2. Structure tes outils sous forme de fichiers de code
Exemple de structure :
servers/
├── google-drive/
│ ├── getDocument.ts
│ ├── getSheet.ts
│ └── index.ts
├── salesforce/
│ ├── updateRecord.ts
│ ├── query.ts
│ └── index.ts
└── slack/
├── getChannelHistory.ts
└── index.ts3. Implémente un filtrage agressif des données
Avant d’envoyer des données au modèle :
- Filtre (ne garde que les lignes/éléments pertinents)
- Résumé (génère un résumé concis au lieu de tout envoyer)
- Tokenise (masque les données sensibles)
Exemple :
// Filtrer un tableau avant envoi au modèle
const pendingLeads = allLeads
.filter(lead => lead.Status === "pending")
.slice(0, 5); // Seules 5 lignes transmises4. Utilise un runtime sandboxé
Choisis une solution sécurisée comme :
- Agent Runtime (open-source)
- MCP Sandbox (spécifique MCP)
- Custom (Docker, Kubernetes, ou un simple Node.js sandboxé)
—
Conclusion : MCP + Exécution de code = Le duo gagnant
Le Model Context Protocol (MCP) a révolutionné la connectivité des agents IA. Mais sans exécution de code, il reste limité :
- Coûts prohibitifs (150k tokens pour un workflow simple ? Non merci.)
- Latence insupportable (le modèle digère des pages avant de répondre)
- Fragilité (corruption de données, erreurs JSON à répétition)
L’exécution de code résout ces problèmes en : ✅ Réduisant les coûts de 98% (2k tokens au lieu de 150k) ✅ Supprimant les goulots d’étranglement (logique déterministe dans le runtime) ✅ Sécurisant les données sensibles (tokenisation automatique) ✅ Permettant une scalabilité illimitée (centaines d’outils sans saturation)
Prochaine étape :
- Commence par un workflow simple (ex. : transfert de données entre deux outils)
- Mesure les gains (coût, latence, fiabilité)
- Étends progressivement à tes workflows les plus complexes
Le futur des agents IA ne repose pas sur des appels d’outils directs, mais sur des applications écrites par le modèle. Et toi, qu’attends-tu pour sauter le pas ? 🚀
—
