optimisation-de-contexte

Cette compétence est utilisée pour améliorer l'efficacité du contexte : budgétisation, masquage des observations, stratégie de préfixe ou de cache KV, partitionnement, réduction des coûts en jetons, délimitation de la récupération et extension de la capacité effective du contexte sans réduire la qualité des réponses.

Qu'est-ce que optimisation-de-contexte ?

Cette compétence fournit un ensemble de techniques d'optimisation de contexte pour étendre la capacité effective des fenêtres de contexte limitées. Elle couvre quatre stratégies principales classées par impact et risque : l'optimisation du cache KV (réutilisation des tenseurs pour réduire les coûts et la latence), le masquage des observations (remplacement des sorties verbeuses par des références compactes), la compaction (résumé du contexte lorsque l'utilisation dépasse 70 %), et le partitionnement (répartition du travail entre sous-agents avec des contextes isolés). Elle est utile pour les développeurs et les utilisateurs d'agents IA confrontés à des contraintes de budget de jetons ou de capacité de contexte, et vise à améliorer l'efficacité globale sans compromettre la qualité. La compétence détaille des seuils de déclenchement, des indicateurs de performance (réduction de jetons de 50 à 70 %, taux de succès du cache de 70 %+), et des mises en garde importantes comme l'impact des espaces blancs sur le cache KV ou les risques de compaction tardive. L'accent est mis sur une approche basée sur la mesure pour valider l'efficacité de chaque optimisation.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering/tree/main/skills/context-optimization

Installed? Explore more Développement et programmation skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Techniques d'Optimisation de Contexte

L'optimisation de contexte étend la capacité effective des fenêtres de contexte limitées grâce à une compression, un masquage, une mise en cache et un partitionnement stratégiques. Une optimisation efficace augmente la capacité utile sans nécessiter de modèles plus grands ou de fenêtres plus longues — mais seulement lorsqu'elle est appliquée avec une discipline de mesure. Les techniques ci-dessous sont classées par impact et risque.

Quand l'Activer

Activez cette compétence lorsque :

  • Les budgets de contexte ou les coûts en jetons contraignent la complexité des tâches
  • Le masquage des observations peut remplacer les sorties verbeuses des outils par des références récupérables
  • Le taux de succès du préfixe ou du cache KV a besoin d'être amélioré
  • La délimitation de la récupération peut réduire la charge de contexte non pertinente
  • Le partitionnement du contexte peut étendre la capacité effective entre agents
  • Des déclencheurs de budget sont nécessaires pour le masquage, la compaction ou le partitionnement

N'activez pas cette compétence pour les travaux adjacents gérés par d'autres compétences :

  • Expliquer pourquoi l'attention ou les fenêtres de contexte se comportent ainsi : fondements-contexte.
  • Diagnostiquer les problèmes actifs de perte au milieu, d'empoisonnement, de distraction, de confusion ou de conflit : dégradation-contexte.
  • Concevoir un résumé de passation structuré pour une longue conversation : compression-contexte.
  • Stocker les sorties volumineuses, les plans ou les journaux sous forme de fichiers : contexte-fichiers.
  • Réécritures initiées par le modèle de son propre contexte et leur coût de re-préfixe : contexte-auto-géré.

Concepts Fondamentaux

Appliquez quatre stratégies principales dans cet ordre de priorité :

  1. Optimisation du cache KV — Réorganisez et stabilisez la structure de l'invite afin que le moteur d'inférence réutilise les tenseurs Clé/Valeur mis en cache. C'est l'optimisation la moins coûteuse lorsque l'exécution prend en charge la mise en cache du préfixe : faible risque de qualité, économies immédiates de coûts et de latence. Appliquez-la en premier lorsque des préfixes stables existent.

  2. Masquage des observations — Remplacez les sorties verbeuses des outils par des références compactes une fois que leur objectif est atteint. Les sorties d'outils peuvent dominer les trajectoires des agents (revendiquer-optimisation-contexte-domination-sorties-outils), donc le masquage donne souvent les gains de capacité les plus importants. Le contenu original reste récupérable si nécessaire en aval.

  3. Compaction — Résumez le contexte accumulé lorsque l'utilisation dépasse 70 %, puis réinitialisez avec le résumé. Cela distille le contenu de la fenêtre tout en préservant l'état critique de la tâche. La compaction est avec perte — appliquez-la après que le masquage a déjà éliminé le volume de faible valeur.

  4. Partitionnement du contexte — Répartissez le travail entre sous-agents avec des contextes isolés lorsqu'une seule fenêtre ne peut pas contenir l'ensemble du problème. Chaque sous-agent opère dans un contexte propre axé sur sa sous-tâche. Réservez cela pour les tâches où le contexte estimé dépasse 60 % de la limite de la fenêtre, car les frais généraux de coordination sont réels.

Le principe directeur : la qualité du contexte importe plus que la quantité. Chaque optimisation préserve le signal tout en réduisant le bruit. Mesurez avant d'optimiser, puis mesurez l'effet de l'optimisation.

Sujets Détaillés

Stratégies de Compaction

Déclenchez la compaction lorsque l'utilisation du contexte dépasse 70 % : résumez le contexte actuel, puis réinitialisez avec le résumé. Cela distille le contenu de la fenêtre avec une haute fidélité, permettant une continuation avec une dégradation minimale des performances. Priorisez la compression des sorties d'outils en premier (elles consomment 80 %+ des jetons), puis des anciens tours de conversation, puis des documents récupérés. Ne compressez jamais l'invite système — elle ancre le comportement du modèle et sa suppression entraîne une dégradation imprévisible.

Préservez différents éléments par type de message :

  • Sorties d'outils : Extrayez les constatations clés, les mesures, les codes d'erreur et les conclusions. Supprimez la sortie brute verbeuse, les traces de pile (sauf si le débogage est en cours) et les en-têtes standard.
  • Tours de conversation : Conservez les décisions, les engagements, les préférences de l'utilisateur et les changements de contexte. Supprimez le remplissage, les formules de politesse et les allers-retours exploratoires qui ont mené à une conclusion déjà capturée.
  • Documents récupérés : Conservez les affirmations, les faits et les points de données pertinents pour la tâche active. Supprimez les preuves à l'appui et les élaborations qui ont servi à un raisonnement ponctuel.

Visez une réduction de 50 à 70 % des jetons avec une dégradation de qualité inférieure à 5 %. Si la compaction dépasse 70 % de réduction, vérifiez le résumé pour détecter une perte d'informations critiques — une compaction trop agressive est le mode de défaillance le plus courant.

Masquage des Observations

Masquez les observations de manière sélective en fonction de la récence et de la pertinence continue — pas uniformément. Appliquez ces règles :

  • Ne jamais masquer : Les observations critiques pour la tâche en cours, les observations du tour le plus récent, les observations utilisées dans les chaînes de raisonnement actives, et les sorties d'erreur lorsque le débogage est en cours.
  • Masquer après 3+ tours : Les sorties verbeuses dont les points clés ont déjà été extraits dans le flux de la conversation. Remplacez par une référence compacte : [Obs:{ref_id} masqué. Clé : {résumé}. Contenu complet récupérable.]
  • Toujours masquer immédiatement : Les sorties répétées/dupliquées, les en-têtes et pieds de page standard, les sorties déjà résumées plus tôt dans la conversation.

Le masquage devrait atteindre une réduction de 60 à 80 % des observations masquées avec un impact sur la qualité inférieur à 2 %. La clé est de maintenir la récupérabilité — stockez le contenu complet en externe et conservez l'ID de référence dans le contexte pour que l'agent puisse demander l'original si nécessaire.

Optimisation du Cache KV

Maximisez les succès du cache de préfixe en structurant les invites de sorte que le contenu stable occupe le préfixe et que le contenu dynamique apparaisse à la fin. Le cache KV stocke les tenseurs Clé et Valeur calculés pendant l'inférence ; lorsque des requêtes consécutives partagent un préfixe identique, les tenseurs mis en cache sont réutilisés, économisant à la fois des coûts et de la latence.

Appliquez cet ordre dans chaque invite :

  1. Invite système (la plus stable — ne change jamais au sein d'une session)
  2. Définitions des outils (stables entre les requêtes)
  3. Modèles et exemples few-shot fréquemment réutilisés
  4. Historique de la conversation (grandit mais partage le préfixe avec les tours précédents)
  5. Requête actuelle et contenu dynamique (le moins stable — toujours en dernier)

Concevez les invites pour la stabilité du cache : supprimez les horodatages, les compteurs de session et les IDs de requête de l'invite système. Déplacez les métadonnées dynamiques dans un message utilisateur séparé ou un résultat d'outil où elles ne cassent pas le préfixe. Même un seul changement d'espace blanc dans le préfixe invalide l'ensemble du bloc mis en cache en aval de ce changement. La même règle s'applique à toute modification de compaction ou de masquage appliquée à l'historique antérieur : son coût est le texte qui la suit, donc regroupez ces modifications et préférez-les près de la fin du contexte.

Visez un taux de succès du cache de 70 %+ pour les charges de travail stables. À grande échelle, cela se traduit par une réduction des coûts de 50 %+ et une réduction de la latence de 40 %+ sur les jetons mis en cache.

Partitionnement du Contexte

Répartissez le travail entre sous-agents lorsqu'un seul contexte ne peut pas contenir l'ensemble du problème sans déclencher une compaction agressive. Chaque sous-agent opère dans un contexte propre et ciblé pour sa sous-tâche, puis renvoie un résultat structuré à un agent coordinateur.

Planifiez le partitionnement lorsque le contexte estimé de la tâche dépasse 60 % de la limite de la fenêtre. Décomposez la tâche en sous-tâches indépendantes, attribuez chacune à un sous-agent et agrégez les résultats. Validez que toutes les partitions sont terminées avant de fusionner, fusionnez les résultats compatibles et appliquez une synthèse si la sortie agrégée dépasse toujours le budget.

Cette approche permet une séparation des préoccupations — le contexte de recherche détaillé reste isolé dans les sous-agents tandis que le coordinateur se concentre sur la synthèse. Cependant, la coordination a un coût réel en jetons : l'invite du coordinateur, l'agrégation des résultats et la gestion des erreurs consomment tous des jetons. Ne partitionnez que lorsque les économies dépassent ces frais généraux.

Gestion du Budget

Allouez des budgets de jetons explicites entre les catégories de contexte avant le début de la session : invite système, définitions des outils, documents récupérés, historique des messages, sorties des outils et une réserve tampon (5 à 10 % du total). Surveillez l'utilisation par rapport au budget en continu et déclenchez l'optimisation lorsque toute catégorie dépasse son allocation ou que l'utilisation totale dépasse 70 %.

Utilisez une optimisation basée sur des déclencheurs plutôt qu'une optimisation périodique. Surveillez ces signaux :

  • Utilisation des jetons supérieure à 80 % — déclenchez la compaction
  • Indicateurs de dégradation de l'attention (répétition, instructions manquées) — déclenchez le masquage + compaction
  • Le score de qualité chute en dessous de la base de référence — vérifiez la composition du contexte avant d'optimiser

Guide Pratique

Cadre Décisionnel d'Optimisation

Sélectionnez la technique d'optimisation en fonction de ce qui domine le contexte :

Composition du ContextePremière ActionDeuxième Action
Les sorties d'outils dominent (>50 %)Masquage des observationsCompaction des tours restants
Les documents récupérés dominentRésuméPartitionnement si les docs sont indépendants
L'historique des messages domineCompaction avec préservation sélectivePartitionnement pour de nouvelles sous-tâches
Plusieurs composants contribuentOptimisation du cache KV d'abord, puis superposition du masquage + compaction
Proche de la limite avec débogage actifMasquer uniquement les sorties d'outils résolues — préserver les détails d'erreur

Objectifs de Performance

Suivez ces indicateurs pour valider l'efficacité de l'optimisation :

  • Compaction : Réduction de 50 à 70 % des jetons, dégradation de qualité <5 %, surcharge de latence <10 % de l'étape de compaction elle-même
  • Masquage : Réduction de 60 à 80 % des observations masquées, impact sur la qualité <2 %, surcharge de latence quasi nulle
  • Optimisation du cache : Taux de succès de 70 %+ pour les charges de travail stables, réduction des coûts de 50 %+, réduction de la latence de 40 %+
  • Partitionnement : Économies nettes de jetons après prise en compte des frais généraux du coordinateur ; seuil de rentabilité nécessitant généralement 3+ sous-tâches

Itérez sur les stratégies en fonction des résultats mesurés. Si une technique d'optimisation n'améliore pas de manière mesurable l'indicateur cible, supprimez-la — les mécanismes d'optimisation eux-mêmes consomment des jetons et ajoutent de la latence.

Exemples

Exemple 1 : Déclencheur de Compaction

if context_tokens / context_limit > 0.8:
    context = compact_context(context)

Exemple 2 : Masquage d'Observation

if len(observation) > max_length:
    ref_id = store_observation(observation)
    return f"[Obs:{ref_id} masqué. Clé : {extract_key(observation)}]"

Exemple 3 : Ordonnancement Favorable au Cache

# Contenu stable d'abord
context = [system_prompt, tool_definitions]  # Mettable en cache
context += [reused_templates]  # Réutilisable
context += [unique_content]  # Unique

Exemple 4 : Politique d'Optimisation déclenchée par Budget

budgets:
  tool_outputs: 35%
  message_history: 30%
  retrieved_documents: 20%
  reserved_buffer: 15%
triggers:
  tool_outputs_over_budget: masquer les observations résolues
  total_context_over_70_percent: compacter l'historique des messages
  repeated_irrelevant_retrievals: resserrer la portée de la récupération

Directives

  1. Mesurez avant d'optimiser — connaissez votre état actuel
  2. Appliquez le masquage avant la compaction — supprimez d'abord le volume de faible valeur, puis résumez ce qui reste
  3. Concevez pour la stabilité du cache avec des invites cohérentes
  4. Partitionnez avant que le contexte ne devienne problématique
  5. Surveillez l'efficacité de l'optimisation dans le temps
  6. Équilibrez les économies de jetons avec la préservation de la qualité
  7. Testez l'optimisation à l'échelle de la production
  8. Implémentez une dégradation gracieuse pour les cas limites

Pièges

  1. Les espaces blancs cassent le cache KV : Même un seul changement d'espace blanc ou de nouvelle ligne dans le préfixe de l'invite invalide l'ensemble du bloc de cache KV en aval de ce point. Épinglez les invites système comme des chaînes immuables — n'interpolez pas d'horodatages, de numéros de version ou d'IDs de session dans celles-ci. Différenciez les modèles d'invite octet par octet entre les déploiements.

  2. Les horodatages dans les invites système détruisent les taux de succès du cache : Inclure Date actuelle : {aujourd'hui} ou un contenu dynamique similaire dans l'invite système force un échec de cache complet chaque nouveau jour (ou chaque requête, si l'heure de la journée est utilisée). Déplacez les métadonnées dynamiques dans un message utilisateur ou un résultat d'outil séparé ajouté après le préfixe stable.

  3. La compaction sous pression perd un état critique : Lorsque le modèle effectuant la compaction est lui-même sous pression de contexte (>85 % d'utilisation), sa qualité de résumé se dégrade — il omet les objectifs de la tâche, supprime les contraintes utilisateur et aplatit l'état nuancé. Déclenchez la compaction à 70-80 %, pas à 90 %+. Si la compaction doit avoir lieu tard, utilisez un appel de modèle séparé avec un contexte propre ne contenant que le matériau à résumer.

  4. Masquer les sorties d'erreur casse les boucles de débogage : Un masquage trop agressif cache les messages d'erreur, les traces de pile et les détails d'échec dont l'agent a besoin dans les tours suivants pour diagnostiquer et résoudre les problèmes. Pendant le débogage actif (erreur dans les 3 derniers tours), suspendez le masquage pour toutes les observations liées aux erreurs jusqu'à ce que le problème soit résolu.

  5. Les frais généraux de partitionnement peuvent dépasser les économies : Chaque sous-agent nécessite sa propre invite système, ses définitions d'outils et ses messages de coordination. Pour les tâches avec moins de 3 sous-tâches indépendantes, les frais généraux de coordination dépassent souvent les économies de contexte. Estimez les jetons totaux (coordinateur + tous les sous-agents) avant de vous engager dans le partitionnement.

  6. Le coût des échecs de cache augmente après les changements de déploiement : Réorganiser les outils, reformuler l'invite système ou modifier les exemples few-shot entre les déploiements invalide l'ensemble du cache de préfixe, provoquant une augmentation temporaire des coûts de 2 à 5 fois jusqu'à ce que le nouveau cache se réchauffe. Déployez les modifications d'invite progressivement et surveillez le taux de succès du cache pendant les fenêtres de déploiement.

  7. La compaction crée une fausse confiance dans les résumés obsolètes : Une fois le contexte compacté, le résumé semble faisant autorité mais peut refléter un état obsolète. Si la tâche a évolué depuis la compaction (nouvelles exigences utilisateur, hypothèses corrigées), le résumé transporte silencieusement des informations obsolètes. Après la compaction, revalidez le résumé par rapport à l'objectif actuel de la tâche avant de continuer.

Intégration

Cette compétence gère les tactiques d'efficacité des jetons et la politique budgétaire. Les compétences adjacentes gèrent le diagnostic, le stockage et l'architecture :

  • fondements-contexte : modèles mentaux pour expliquer pourquoi la qualité du contexte et le placement de l'attention sont importants.
  • dégradation-contexte : diagnostic lorsque la qualité des sorties a déjà baissé.
  • compression-contexte : résumé avec perte et stratégie de passation.
  • contexte-fichiers : déchargement basé sur des fichiers pour les sorties et journaux complets.
  • modèles-multi-agents : partitionnement du travail entre contextes d'agents isolés.
  • briefing-latent : rétention sélective KV à travers l'orchestre...

Individual skills in this repo

This repo contains 19 individual skills — each has its own dedicated page.

advanced-evaluation

This skill should be used for advanced LLM evaluation: LLM-as-judge systems, direct scoring, pairwise comparison, rubric calibration, evaluator bias mitigation, confidence scoring, and automated quality assessment.

bdi-mental-states

This skill should be used when modeling agent mental states with BDI concepts: beliefs, desires, intentions, RDF-to-belief transformations, rational agency traces, cognitive agents, BDI ontologies, and neuro-symbolic AI integration.

book-sft-pipeline

This skill should be used for book-to-SFT pipelines: ePub extraction, literary segmentation, author-voice dataset construction, style-transfer training, LoRA workflows, and model evaluation for voice replication.

comprehensive-research-agent

Ensure thorough validation, error recovery, and transparent reasoning in research tasks with multiple tool calls

context-compression

This skill should be used when long-running agent sessions need context compression, structured summarization, compaction, token-per-task optimization, or durable handoff summaries that preserve decisions, files, risks, and next actions.

context-degradation

This skill should be used for diagnosing and mitigating context degradation: lost-in-middle failures, context poisoning, context clash, context confusion, attention-pattern issues, and agent performance degradation caused by accumulated or conflicting context.

context-fundamentals

This skill should be used to explain or reason about the foundational concepts of context engineering: what context is, the anatomy of a context window, how attention mechanics work, the U-shaped attention curve, why context quality matters more than quantity, and the mental models needed to interpret every other context-engineering decision. Use this for conceptual explanation, onboarding, and background reading. Route operational work to the specialized skills: debugging attention failures goes to context-degradation, token-efficiency work goes to context-optimization, conversation summarization goes to context-compression, and project-shape decisions go to project-development.

evaluation

This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and outcome measurement for agent pipelines.

filesystem-context

This skill should be used when agent work needs file-backed context: durable scratchpads, tool-output offloading, just-in-time discovery, cross-agent handoff files, filesystem memory, or cleanup policies for context stored outside the prompt.

harness-engineering

This skill should be used when designing autonomous agent harnesses: research loops, evaluation scaffolds, locked and editable surfaces, durable logs, novelty gates, pruning, rollback, PR preparation, and human approval boundaries.

hosted-agents

This skill should be used when designing hosted or background agent infrastructure: sandboxed execution, remote coding environments, warm pools, session persistence, multiplayer collaboration, self-spawning agents, or Modal-style sandboxes.

latent-briefing

This skill should be used when the user asks to "share memory between agents", "KV cache compaction for multi-agent", "orchestrator worker context", "latent briefing", "reduce worker tokens", "cross-agent memory without summarization", or discusses Attention Matching compaction, recursive language models with workers, or token explosion in hierarchical agents.

long-horizon-prompting

This skill should be used when writing, enhancing, or evaluating the launch prompt for a long-running autonomous agent or a parallel multi-agent orchestration attacking a hard problem: pseudo-formal task briefs that define terms and an exact success predicate linguistically, enumerate non-counting outcomes, set persistence rules with explicit stop and return conditions and effort floors, manage a diverse portfolio of parallel approaches with an approach registry and blocked-route bookkeeping, and gate the return on adversarial audit. Route agent topology and coordination protocols to multi-agent-patterns, runtime control surfaces and loop governance to harness-engineering, evaluator and quality-gate construction to evaluation, judge design to advanced-evaluation, and compaction or memory mechanics to context-compression and memory-systems.

memory-systems

This skill should be used for persistent semantic memory in agent systems: cross-session knowledge retention, entity tracking, temporal validity, graph or vector retrieval, memory consolidation, and memory benchmark selection. Route file-backed scratchpads to filesystem-context, handoff summaries to context-compression, and token-efficiency tactics to context-optimization.

multi-agent-patterns

This skill should be used when designing multi-agent systems that need context isolation, supervisor or swarm coordination, explicit handoffs, parallel execution, or a decision on whether multiple agents are justified.

project-development

This skill should be used for project-level decisions about LLM-powered systems: whether an LLM is the right primitive for the task at hand, the shape of a multi-stage batch or agent pipeline, token and cost estimation, choosing between single-agent and multi-agent at the project level, structured output design for downstream parsing, and structuring agent-assisted iteration. Use this when the unit of work is a whole project or a multi-stage pipeline. Route individual tool design to tool-design and individual skill-loading or context-budget tactics to context-optimization.

self-improvement-loops

This skill should be used when the harness, scaffold, workflow, or optimizer itself is the optimization target: recursive self-improvement (RSI) loops, meta-harnesses, self-improving harnesses that mine their own failures and propose bounded edits, evolutionary or population-based search over agent scaffolds, acceptance gates for self-modifying systems, and agentic context evolution where the mechanism that produces context is versioned and evolved. Route governance of a single autonomous loop (locked surfaces, durable logs, rollback, novelty gates, approval boundaries) to harness-engineering, measurement and quality-gate design to evaluation, judge design to advanced-evaluation, and remote sandbox infrastructure to hosted-agents.

self-managed-context

This skill should be used when a model gets read-write control over its own live context window instead of a harness-scheduled compaction policy: the context exposed as an editable file the model rewrites with code tools, model-driven eviction and in-place updates, the harness invariants that keep self-editing safe (pinned prefix, edit gate, edit receipts, budget readouts, rollback on overflow), the prefix-cache cost of mid-context edits, and steering or training the model's own context-editing strategy. Route note content and fixed-threshold summarization to context-compression, cache-stable layout under harness control to context-optimization, file offloading to filesystem-context, and loop governance to self-improvement-loops.

tool-design

This skill should be used for the tool-interface layer of an agent system specifically: writing tool descriptions agents can route on, designing tool schemas and response formats, naming conventions, actionable error recovery messages, MCP server design, tool-set consolidation, and deciding when to add or remove an individual tool. Use this when the unit of work is a single tool or a set of tools. Route project-shape, pipeline architecture, and task-model-fit decisions to project-development; route deciding whether to introduce sub-agents to multi-agent-patterns.

Skills associés