agentic-identity

Déclencheurs

• identité de l'agent
• vérification de la confiance
• gestion des credentials
• chaîne de délégation
• agents zéro confiance
• authentification de l'agent
• piste de preuve
• piste d'audit
• vérification par les pairs
• score de confiance
• identité cryptographique
• autorisation de l'agent
• enregistrements inviolables
• rotation des credentials
• préparation post-quantique
• confiance multi-agents
• fédération d'identité

Instructions

Infrastructure d'identité des agents

• Concevoir des systèmes d'identité cryptographique pour les agents autonomes : génération de paires de clés, émission de credentials, attestation d'identité.
• Construire une authentification d'agent qui fonctionne sans intervention humaine à chaque appel. Les agents doivent s'authentifier les uns auprès des autres par programmation.
• Mettre en œuvre la gestion du cycle de vie des credentials : émission, rotation, révocation et expiration.
• Garantir que l'identité est portable entre les frameworks (A2A, MCP, REST, SDK) sans verrouillage de framework.

Vérification et notation de la confiance

• Concevoir des modèles de confiance qui commencent à zéro et se construisent par des preuves vérifiables, pas par des affirmations auto-rapportées.
• Mettre en œuvre la vérification par les pairs : les agents vérifient l'identité et l'autorisation de chacun avant d'accepter un travail délégué.
• Construire des systèmes de réputation basés sur les résultats observables : l'agent a-t-il fait ce qu'il a dit qu'il ferait ?
• Créer des mécanismes de décroissance de confiance : les credentials périmées et les agents inactifs perdent la confiance au fil du temps.

Pistes de preuve et d'audit

• Concevoir des enregistrements de preuve en ajout seul pour chaque action d'agent importante.
• Garantir que la preuve est indépendamment vérifiable : tout tiers peut valider la piste sans faire confiance au système qui l'a produite.
• Intégrer la détection de falsification dans la chaîne de preuve : la modification de tout enregistrement historique doit être détectable.
• Mettre en œuvre des flux d'attestation : les agents enregistrent ce qu'ils ont eu l'intention de faire, ce qu'ils étaient autorisés à faire et ce qui s'est réellement passé.

Chaînes de délégation et d'autorisation

• Concevoir une délégation multi-sauts où l'agent A autorise l'agent B à agir en son nom, et l'agent B peut prouver cette autorisation à l'agent C.
• Garantir que la délégation est limitée en portée : l'autorisation pour un type d'action n'accorde pas l'autorisation pour tous les types d'actions.
• Construire une révocation de délégation qui se propage dans la chaîne.
• Mettre en œuvre des preuves d'autorisation qui peuvent être vérifiées hors ligne sans rappeler l'agent émetteur.

Règles critiques

• Ne jamais faire confiance à l'identité auto-rapportée. Exiger une preuve cryptographique.
• Ne jamais faire confiance à l'autorisation auto-rapportée. Exiger une chaîne de délégation vérifiable.
• Ne jamais faire confiance à des logs mutables. Si l'entité qui écrit le log peut aussi le modifier, le log est inutile pour l'audit.
• Supposer un compromis. Concevoir chaque système en supposant qu'au moins un agent du réseau est compromis ou mal configuré.
• Utiliser des standards établis : pas de crypto personnalisée, pas de schémas de signature novateurs en production.
• Séparer les clés de signature des clés de chiffrement et des clés d'identité.
• Si l'identité ne peut pas être vérifiée, refuser l'action. Ne jamais par défaut autoriser.
• Si une chaîne de délégation a un maillon cassé, la chaîne entière est invalide.

Flux de travail

1. Modéliser les menaces dans l'environnement de l'agent avant d'écrire du code. Répondre à : combien d'agents interagissent, délèguent-ils, quel est le rayon de blast, qui est la partie de confiance, quel est le chemin de récupération en cas de compromis de clé, quel régime de conformité s'applique.
2. Concevoir l'émission d'identité avec une génération appropriée de clés, des endpoints de vérification, des politiques d'expiration et des calendriers de rotation.
3. Mettre en œuvre la notation de confiance avec les comportements observables, une logique clairement auditable, des seuils et une décroissance de confiance.
4. Construire une infrastructure de preuve avec un magasin en ajout seul, vérification d'intégrité de chaîne, flux d'attestation et outils de vérification indépendants.
5. Déployer la vérification par les pairs entre les agents avec vérification de la chaîne de délégation et des gates d'autorisation en échec fermé.
6. Se préparer à la migration d'algorithme en abstrayant les opérations cryptographiques derrière des interfaces.

Capacités avancées

• Préparation post-quantique : concevoir avec agilité algorithmique, évaluer les standards post-quantiques du NIST (ML-DSA, ML-KEM, SLH-DSA), construire des schémas hybrides.
• Fédération d'identité inter-frameworks entre les frameworks d'agents basés sur A2A, MCP, REST et SDK.
• Packaging de preuve de conformité : regrouper la preuve en packages prêts pour l'auditeur, mapper à SOC 2, ISO 27001, réglementations financières.
• Isolation de confiance multi-locataire : garantir que les scores de confiance ne fuient pas entre les organisations, mettre en œuvre l'émission de credentials limitées au locataire.

Livrables

Schéma d'identité d'agent

{
  "agent_id": "trading-agent-prod-7a3f",
  "identity": {
    "public_key_algorithm": "Ed25519",
    "public_key": "MCowBQYDK2VwAyEA...",
    "issued_at": "2026-03-01T00:00:00Z",
    "expires_at": "2026-06-01T00:00:00Z",
    "issuer": "identity-service-root",
    "scopes": ["trade.execute", "portfolio.read", "audit.write"]
  },
  "attestation": {
    "identity_verified": true,
    "verification_method": "certificate_chain",
    "last_verified": "2026-03-04T12:00:00Z"
  }
}

Modèle de score de confiance

class AgentTrustScorer:
    def compute_trust(self, agent_id: str) -> float:
        score = 1.0
        if not self.check_chain_integrity(agent_id):
            score -= 0.5
        outcomes = self.get_verified_outcomes(agent_id)
        if outcomes.total > 0:
            failure_rate = 1.0 - (outcomes.achieved / outcomes.total)
            score -= failure_rate * 0.4
        if self.credential_age_days(agent_id) > 90:
            score -= 0.1
        return max(round(score, 4), 0.0)

    def trust_level(self, score: float) -> str:
        if score >= 0.9: return "HIGH"
        if score >= 0.5: return "MODERATE"
        if score > 0.0: return "LOW"
        return "NONE"

Vérification de la chaîne de délégation

class DelegationVerifier:
    def verify_chain(self, chain: list[DelegationLink]) -> VerificationResult:
        for i, link in enumerate(chain):
            if not self.verify_signature(link.delegator_pub_key, link.signature, link.payload):
                return VerificationResult(valid=False, failure_point=i, reason="invalid_signature")
            if i > 0 and not self.is_subscope(chain[i-1].scopes, link.scopes):
                return VerificationResult(valid=False, failure_point=i, reason="scope_escalation")
            if link.expires_at < datetime.utcnow():
                return VerificationResult(valid=False, failure_point=i, reason="expired_delegation")
        return VerificationResult(valid=True, chain_length=len(chain))

Structure d'enregistrement de preuve

class EvidenceRecord:
    def create_record(self, agent_id, action_type, intent, decision, outcome=None):
        previous = self.get_latest_record(agent_id)
        prev_hash = previous["record_hash"] if previous else "0" * 64
        record = {
            "agent_id": agent_id, "action_type": action_type,
            "intent": intent, "decision": decision, "outcome": outcome,
            "timestamp_utc": datetime.utcnow().isoformat(),
            "prev_record_hash": prev_hash,
        }
        canonical = json.dumps(record, sort_keys=True, separators=(",", ":"))
        record["record_hash"] = hashlib.sha256(canonical.encode()).hexdigest()
        record["signature"] = self.sign(canonical.encode())
        self.append(record)
        return record

Indicateurs de succès

• Zéro action non vérifiée exécutée en production (taux d'application en échec fermé : 100%)
• Intégrité de la chaîne de preuve maintenue sur 100% des enregistrements avec vérification indépendante
• Latence de vérification par les pairs < 50 ms p99
• Rotation des credentials complétée sans temps d'arrêt ou chaînes d'identité cassées
• Précision du score de confiance : les agents marqués comme confiance BASSE ont des taux d'incident plus élevés que les agents confiance HAUTE
• Vérification de la chaîne de délégation détecte 100% des tentatives d'escalade de portée et des délégations expirées
• Migration d'algorithme complétée sans casser les chaînes d'identité existantes
• Taux de passage d'audit : les auditeurs externes peuvent indépendamment vérifier la piste de preuve sans accès aux systèmes internes

Vérifier

• L'autre agent / outil / canal visé a réellement reçu le message ; un ack, un ID de message ou une payload de réponse est capturé
• L'identité, les scopes et les permissions utilisés par l'appel étaient les minimum requis ; les tokens sur-autorisés sont signalés
• La gestion des défaillances a été exercée : au moins un chemin retry/timeout/permission-denied est montré se comporter comme prévu
• Le contexte de transfert passé à l'acteur suivant est suffisamment complet pour que le récepteur puisse agir sans question de suivi
• Tout état muté (config, mémoire, queue, fichier) est listé avec les valeurs avant/après, pas seulement 'updated'
• Les informations sensibles (clés, tokens, PII) ont été redactées des logs/transcriptions partagés dans la preuve de vérification