--- title: "Le codage agentique requiert une validation humaine arrimée au réel physique" date: 2026-05-21 canonical: https://patrickaudley.com/#post-human-signoff-for-agentic-code cross-posted-from: https://www.linkedin.com/feed/update/urn:li:activity:7463256842350022656/ source-platform: LinkedIn tags: [ai-governance, software-security, ai-coding, appsec, zero-trust, devsecops, coding-ethos] mentions: [https://patrickaudley.com/#proj-coding-ethos] author: Patrick Colm Audley author-url: https://patrickaudley.com/ license: Creative Commons BY-NC-SA CAv2.5 lang: fr --- # Le codage agentique requiert une validation humaine arrimée au réel physique > À mesure que les agents de codage IA passent d'outils d'autocomplétion passive à des contributeurs autonomes exécutant des branches fonctionnelles entières, nous fonçons vers un angle mort majeur de sécurité : comment prouver qu'un véritable humain a revu et vérifié le code généré par agent avant la production ? À mesure que les agents de codage IA passent d'outils d'autocomplétion passive à des contributeurs autonomes exécutant des branches fonctionnelles entières, nous fonçons vers un angle mort majeur de sécurité : comment prouver qu'un véritable humain a effectivement revu et vérifié le code généré par agent avant son arrivée en production ? Ce n'est pas un problème *nouveau*, mais il est assurément plus *urgent* maintenant. Dans mon projet [coding-ethos](https://github.com/paudley/coding-ethos), nous nous concentrons fortement sur la construction de garde-fous policy-as-code pour agents IA : politiques Common Expression Language, hooks Git, sandboxing et serveurs Model Context Protocol, afin que des agents autonomes ne puissent pas livrer du code enfreignant les normes de votre équipe, même si vous n'êtes pas dans la boucle. Mais même les barrières automatisées les plus robustes ne constituent que la moitié du combat. La couche ultime de défense en profondeur exige de vrais yeux relisant le code critique. Dans un flux pleinement agentique, la signature SSH ou GPG traditionnelle des commits ne suffit plus, et elle est souvent automatisée. Si un processus agent ou un environnement local est compromis, ou déplacé par une injection de prompt sophistiquée, ces identifiants stockés peuvent être détournés. Ou les gens peuvent simplement céder à la paresse. Il nous faut un modèle de confirmation développeur zero-trust, cryptographiquement lié à la réalité physique : **Vérification biométrique :** validation rapide et peu frictionnelle, comme Face ID ou Touch ID, prouvant qu'un développeur vivant et autorisé est activement devant l'écran. **Vérification temporelle :** garantie que l'approbation humaine survient précisément pendant la fenêtre de commit, afin d'éliminer les attaques par rejeu. **Vérification géophysique :** confirmation que la localisation physique du développeur s'aligne avec la télémétrie attendue et les frontières de confiance. Lorsqu'un agent autonome propose un changement architectural critique, la barrière finale ne devrait pas être simplement une coche verte dans un pipeline CI. Il faut une assertion humaine impossible à usurper. Je conçois actuellement cette couche exacte de défense pour coding-ethos, et je souhaite ouvrir la discussion au réseau : comment votre équipe d'ingénierie trace-t-elle la frontière entre l'application automatisée de politiques et la validation humaine ferme ? À mesure que les agents prennent en charge de plus grands pans du code, comment éviter que la fatigue de revue transforme la vérification humaine en tampon automatique ? Discutons-en. Je cherche activement à faire passer ce cadre de vérification d'un patron de conception à une intégration de plateforme réelle. Si vous bâtissez un produit d'identification biométrique rapide, ou si vous opérez une plateforme de sécurité de chaîne d'approvisionnement logicielle en entreprise et souhaitez explorer une intégration d'essai avec coding-ethos, [prenons contact](#contact). ## Threat Modeling Autonomous Dev Agents: How do we cryptographically prove a human actually reviewed a commit? **Date :** 2026-05-21 · **Republié depuis :** [Reddit (r/cybersecurity)](https://www.reddit.com/r/cybersecurity/comments/1tjqhnc/threat_modeling_autonomous_dev_agents_how_do_we/) · **Étiquettes :** `FOSS Tool` Hey everyone, I’ve been spending a lot of time lately threat-modelling fully agentic coding workflows. As tools move from passive autocomplete to autonomous agents that execute entire feature branches, we are opening a massive supply-chain blind spot. I maintain an open-source project called `coding-ethos`, which focuses on building policy-as-code guardrails for AI agents (using CEL policies, Git hooks, sandboxing, and MCP servers) to ensure agents can’t ship code that violates team standards. But even with robust automated gates, I keep hitting a wall with the ultimate layer of defence-in-depth: human verification. * I have some very mathy thoughts about this, but I've kept them out of the post for now * The Threat Vector Traditional SSH or GPG commit signing is no longer sufficient. If a local environment or agent process is compromised—say, via a sophisticated prompt injection or a malicious package—those stored credentials can be hijacked by the agent to sign off on a malicious commit. If it passes the automated CI/CD tests, it merges. How do we prove that "real eyes" actually reviewed critical code before it hits production? The Proposed Defence Layer I'm working on integrating a zero-trust developer confirmation model for critical commits that is cryptographically tied to physical reality. To actually trust an agent's output, the human sign-off needs to be: Biometrically Verified: Fast, low-friction validation (e.g., WebAuthn/Passkeys via TouchID/FaceID) that proves a living, authorized developer is actively at the glass, signing the specific commit hash. Temporally Verified: Ensuring the human approval happens precisely at the moment of the commit window to eliminate replay attacks or asynchronous approvals. Geophysically Verified: Confirming the physical location/telemetry of the developer aligns with expected trusted boundaries at the time of signing. The Problem When an autonomous agent proposes a critical architectural change, a green checkmark from a CI pipeline isn't enough. It needs to be an un-spoofable human assertion, but it also can't be so high-friction that developers just blindly spam their fingerprint reader out of "reviewer fatigue." I'm currently trying to take this from a design pattern into a live architecture within `coding-ethos`, but I want a sanity check from this sub: How are your AppSec teams drawing the line between automated policy enforcement and hard human sign-off for AI-generated code? Has anyone started integrating biometric auth directly into pre-commit/pre-push git hooks for critical branch merges? What are the obvious bypasses to this triad (Biometric/Temporal/Geophysical) that I am missing in my threat model? I would love to hear your thoughts or see if anyone else is building in this exact IAM/AppSec intersection. --- *Publié initialement le 2026-05-21 — [LinkedIn](https://www.linkedin.com/feed/update/urn:li:activity:7463256842350022656/). Version canonique à . Auteur : [Patrick Colm Audley](https://patrickaudley.com/). *