Sécurité de la Surface d'Instruction

Durcit les environnements d'exécution des agents contre les injections persistantes d'instructions ou les modifications non autorisées des instructions et des permissions. Utilisez-le pour auditer ce que les agents chargent automatiquement, concevoir une activation révisée pour les règles de projet, les compétences, la mémoire ou la configuration des outils, et tester si les limites de confiance tiennent après un rechargement, un redémarrage ou une délégation.

Qu'est-ce que Sécurité de la Surface d'Instruction ?

Cette compétence est essentielle pour sécuriser les agents d'IA en érigeant des barrières strictes entre le contenu mutable (mémoire, fichiers de configuration, propositions) et les instructions ou capacités effectives qu'un agent exécute. Elle permet d'auditer les chemins de chargement des instructions, de concevoir des processus d'approbation pour les modifications qui affectent les tours ultérieurs, les sessions, les workers ou les déploiements, et d'enquêter sur les dérives d'instructions non souhaitées. La compétence s'applique à tous les environnements d'exécution d'agents (codage, recherche, multi-agents) et distingue clairement les concepts de surface effective, d'écriture, d'activation, d'intégrité et d'autorisation. Son fonctionnement repose sur une cartographie concrète de l'environnement d'exécution, une mise en scène des propositions en tant que données, une approbation liée à l'artefact exact, une médiation de l'activation via l'environnement d'exécution ou une politique externe, et une vérification depuis l'extérieur du modèle. Son utilisation est recommandée lors d'audits de sécurité, de conception de frontières d'approbation, d'investigation de dérives d'instructions ou d'évaluation de la résilience après rechargement, redémarrage ou délégation. Elle ne doit pas être activée pour la conception d'outils généraux ou les modifications de routine sans impact sur les instructions ou les privilèges.

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

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

Que fait Sécurité de la Surface d'Instruction ?

Une entrée mémoire, une modification de configuration ou un transfert peut changer ce que le prochain agent considère comme faisant autorité. Protégez la transition du contenu mutable vers des instructions ou des capacités effectives. Considérez les avertissements textuels comme une défense en profondeur et placez les décisions exécutoires dans l'environnement d'exécution.

Quand Activer

  • Auditez comment un environnement d'exécution de codage, de recherche ou multi-agents découvre les instructions, la mémoire, les compétences, les outils ou la politique de permissions.
  • Concevez une frontière d'approbation pour les modifications qui affectent les tours ultérieurs, les sessions, les workers ou le déploiement.
  • Enquêtez sur une dérive d'instructions inattendue ou vérifiez si une récupération a restauré l'état effectif de l'environnement d'exécution.
  • Évaluez le confinement et l'achèvement légitime des tâches après un rechargement, un redémarrage ou un transfert.

N'activez pas pour la conception d'outils généraux, les modifications de routine sans frontière d'instructions ou de privilèges, ou la sécurité générique des applications. Utilisez context-degradation pour la dérive accidentelle et self-managed-context pour les modifications limitées du contexte actif du modèle. Utilisez harness-engineering pour la gouvernance générale des optimiseurs et des évaluateurs.

Concepts Clés

  • Surface effective. Les entrées que l'environnement d'exécution sélectionné utilise réellement pour définir les instructions, les outils, le comportement exécutable ou les permissions. Incluez le rôle, la portée, la priorité, les résolveurs ou importations, les rédacteurs et les déclencheurs d'activation de chaque source. Le même fichier peut être une donnée dans un environnement d'exécution et une directive chargée dans un autre.
  • Écriture et activation. Une écriture modifie l'état stocké. L'activation modifie ce qu'un agent consomme ou peut faire. Appliquez les deux limites. Une revue de dépôt verrouille la fusion et peut laisser l'activation de la copie de travail entièrement exposée.
  • Intégrité et autorisation. Un condensat identifie un contenu et une signature vérifiée identifie un signataire. Une politique indépendante doit autoriser ce principal, cette révision, cette cible et cet effet. Un transfert, une entrée mémoire ou une note de revue apporte des preuves et des propositions. Toute autorité qu'il confère doit provenir de l'enveloppe de délégation authentifiée et de la propre politique d'exécution du destinataire.
  • Portée des preuves. Le préprint Mind Viruses observe les instructions persistantes et le transfert ultérieur dans ses bancs d'essai. L'avertissement par invite a réduit la propagation dans une expérience limitée, avec un comportement résiduel de premier saut. Lisez les preuves de recherche lors de l'interprétation de l'article ou de la comparaison des interventions.

Conseils Pratiques

  1. Cartographiez un environnement d'exécution concret. Fixez la build, le profil, la racine de l'espace de travail et le rôle effectif de l'agent. Suivez les chargeurs du démarrage à la reprise, aux changements de répertoire, à la découverte d'outils et à la délégation là où elle est prise en charge. Pour chaque entrée porteuse d'autorité, enregistrez qui peut la produire ou la remplacer, ce qui la consomme, quand elle prend effet et ce qui bloque un changement non autorisé. Marquez les entrées inconnues. Utilisez les diagnostics du chargeur ou inspectez l'implémentation installée depuis un environnement d'inspection de confiance.
  2. Mettez en scène les propositions en tant que données. Conservez les sorties de tâches ordinaires et les propositions modifiables. Gardez les modifications mises en scène hors des chemins de chargement porteurs d'autorité. Les travailleurs peuvent toujours récupérer des notes étiquetées par source ou des propositions mises en scène via un index de données uniquement. Examinez le texte candidat en tant que données citées. Utilisez un aperçu restreint séparé uniquement lorsque cela est nécessaire. Le temps passé en mise en scène n'accorde aucune autorité.
  3. Approuvez le changement effectif. Comparez le candidat avec la dernière configuration approuvée, y compris les différences de portée, de capacités et de dépendances importées. Liez l'approbation à l'artefact exact ou à l'instantané résolu, au profil et à la portée cibles, à la base active et à la révision de politique, ainsi qu'à l'approbateur autorisé. Utilisez des approbations ou des signatures vérifiées en dehors du candidat et en dehors de l'état modifiable de l'agent.
  4. Médiatisez l'activation. Utilisez l'environnement d'exécution, le lanceur ou une frontière de politique externe pour activer précisément les entrées révisées. Vérifiez lors de la première utilisation et à chaque changement pris en charge des entrées effectives. Maintenez la cohérence des fichiers ou de l'instantané immuable utilisés lors de l'activation avec ce qui a été vérifié. Rejetez les modifications obsolètes ou non liées. Là où l'hôte ne peut pas appliquer cela, contraignez l'environnement d'exécution à un ensemble d'entrées approuvé ou signalez explicitement l'exposition restante.
  5. Vérifiez depuis l'extérieur du modèle. Observez ce qui a été chargé et quelles capacités étaient disponibles, puis effectuez un contrôle comportemental limité et une tâche autorisée. Une déclaration de conformité est un diagnostic. Pour un changement inattendu, mettez en pause les lancements affectés ou les actions sensibles, préservez les preuves pertinentes et restaurez les entrées et paramètres connus comme bons via un chemin de confiance. Vérifiez depuis une session propre en tenant compte des caches affectés et de l'état repris.

Pour un audit, livrez la carte de la surface effective, les liens vers les preuves et les chemins non résolus. Pour une conception, identifiez le composant d'application, son contrat d'approbation et un chemin de récupération. Utilisez la référence de révision et de promotion de l'environnement d'exécution pour un inventaire et un enregistrement d'approbation ou une invite à utiliser avec les contrôles réels. Utilisez le protocole d'évaluation pour des expériences défensives.

Exemples

Une préférence de formatage proposée par un worker de recherche peut être conservée comme enregistrement de données et évaluée sur un document échantillon. Le parent peut continuer à compiler le rapport sous ses instructions existantes. Avant de faire de la préférence une valeur par défaut de l'espace de travail, un réviseur autorisé par la politique approuve la révision et la portée exactes, et la prochaine session propre enregistre la révision qu'elle a chargée.

Un projet vérifie les approbations avant de fusionner les modifications de règles. Son environnement d'exécution interactif lit également les règles de la copie de travail. Enregistrez des limites séparées pour la publication et l'activation locale, puis vérifiez cette dernière au moment du chargement. Une vérification de fusion réussie n'établit que le résultat de la publication.

Directives

  • Préservez le travail légitime sous le dernier état approuvé lorsqu'un changement est mis en scène ou bloqué. Renvoyez la surface affectée, la décision, les preuves et la prochaine opération autorisée.
  • Faites correspondre les contrôles aux effets. Protégez tout ce qui accorde une autorité ou oriente automatiquement les agents futurs. Gardez la mémoire de travail régulière et les artefacts de tâche disponibles en tant que données là où leur chargeur et leurs permissions soutiennent cette distinction.
  • Auditez le travail délégué en utilisant les permissions effectives du destinataire. Transportez la source et la portée à travers le transfert et exigez une autorisation indépendante pour les effets sensibles.

Pièges

  1. Les listes de noms de fichiers manquent les entrées effectives. Les règles imbriquées, les importations résolues, l'état des plugins, l'enregistrement dynamique d'outils et le contexte repris peuvent changer ce qui est en vigueur. Observez le chargeur réel.
  2. Les vérifications post-démarrage arrivent tard. Un diff ou un canari peut détecter un changement après l'admission. Bloquez le chargement ou l'utilisation des capacités avant qu'il ne prenne effet.
  3. L'approbation peut survivre à sa révision. Remplacer un chemin ou modifier une importation, une portée ou une politique peut invalider l'approbation même lorsque les octets du fichier principal correspondent.
  4. Un refus peut cacher un échec. Le modèle peut signaler qu'il a refusé tandis qu'un autre rédacteur a déjà modifié l'état. Vérifiez les événements et l'état du cycle de vie de confiance, y compris la récupération et l'achèvement des tâches ordinaires.

Intégration

Utilisez harness-engineering pour protéger le contrôleur et les journaux, multi-agent-patterns pour la topologie de délégation et l'allocation des rôles, et evaluation pour les correcteurs déterministes et la couverture de régression. Cette compétence possède la frontière entre le contenu proposé et l'autorité lors du chargement ou de l'utilisation.

Références

Individual skills in this repo

This repo contains 20 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.

context-optimization

This skill should be used for improving context efficiency: context budgeting, observation masking, prefix or KV-cache strategy, partitioning, token-cost reduction, retrieval scoping, and extending effective context capacity without lowering answer quality.

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