EMILIA Protocol MCP Server

officiel

Exiger l'approbation vérifiable hors ligne d'une personne nommée avant qu'un agent IA n'effectue une action irréversible — libération de paiement, modification d'enregistrement, déploiement. Règle des deux personnes, reçus de confiance Ed25519, rédigé par l'IETF, Apache-2.0.

GitHub

Documentation

Protocole EMILIA

Le moteur sans freins

Pendant cinquante ans, la sécurité logicielle a répondu à une seule question : qui est autorisé à entrer ? Pare-feu, OAuth et mots de passe — tous conçus pour vérifier une identité humaine à la porte.

Cette époque touche à sa fin. Les utilisateurs dominants des logiciels ne sont plus des humains ; ce sont des agents IA autonomes. Les agents ne se contentent pas de se connecter — ils écrivent du code, appellent des outils et modifient la réalité à la volée. Chaque RSSI sait qu'une seule mauvaise instruction peut amener un agent à effacer une base de données de production ou à virer de l'argent vers le mauvais compte. Ils bloquent donc le déploiement — laissant dormir des milliards de budget IA qu'ils ne peuvent pas dépenser parce que leurs équipes de conformité ne peuvent pas répondre à une question :

Qui a approuvé cette action ?

La crise de notre génération n'est pas l'authentification. C'est l'autorisation au moment de l'action : comment prouver que ce qu'un agent s'apprête à faire est exactement ce qu'un humain nommément désigné a autorisé — avant son exécution ?

EMILIA est la ceinture de sécurité pour l'ère agentique.

Les journaux de décision sont des témoignages. EMILIA produit des reçus.

Pas de reçu, pas d'action irréversible

Si un agent tente de déplacer de l'argent, de supprimer du code, de déployer en production, de modifier des autorisations ou de changer un état réglementé sans un reçu EMILIA valide, l'outil refuse de s'exécuter — et s'il s'exécute, n'importe qui peut vérifier qui a autorisé exactement quoi, hors ligne, sans faire confiance à personne.

C'est tout le protocole. Le point d'entrée développeur est un simple wrapper autour d'un outil MCP irréversible. Voyez-le en action, entièrement hors ligne, sans clé, sans compte — chaque démonstration exécute la boucle complète (refus → un humain nommé signe l'action exacte → l'outil s'exécute → reçu falsifié rejeté) :

node examples/mcp/payment-server.mjs    # release_payment  — refuses without a receipt
node examples/mcp/github-admin.mjs      # delete_repo      — refuses without a receipt
node examples/mcp/prod-deploy.mjs       # deploy_production — refuses without a receipt

Enveloppez votre propre répartiteur d'outils en production — voir examples/mcp/ et /mcp :

import { withMcpGuard } from '@emilia-protocol/mcp-guard';
const guarded = withMcpGuard(handleTool, {
  annotations: { release_payment: { irreversible: true, action: 'payment.release' } },
}); // missing receipt → refused, never a silent pass

Essayez en 30 secondes

# Issue a receipt offline — no API key, no backend needed
npx @emilia-protocol/issue demo

# Add EMILIA to Claude / Cursor / Cline
npx -y @emilia-protocol/mcp-server

Essayez une approbation réelle par Face ID → Approuvez un virement de 82 000 $ avec votre propre clé d'accès. Voyez à quoi ressemble VÉRIFIÉ. Falsifiez le reçu. Voyez-le échouer.

Vérifiez n'importe quel reçu dans votre navigateur — collez-le, rien n'est téléchargé.

Comment ça marche — quatre actes

EMILIA crash test — an autonomous agent tries to wire $82,000; the policy engine holds it, a named human signs off on their own device, the receipt verifies offline, and a forged copy fails.

Exécutez-le vous-même : node examples/crash-test.mjs — entièrement hors ligne, sans clé API.

  [ INTENT ]          [ DECISION ]           [ CEREMONY ]           [ RECEIPT ]
  Agent calls a     Policy-bound, hash-    Named human signs     Signed, offline-
  tool via MCP   →  pinned: allow /     →  the EXACT action  →  verifiable proof.
                    allow-with-signoff /   on their own          Tamper it:
                    deny  (+observe        device (passkey).      fails by design.
                    mode: zero change      What they saw =
                    to production)         what they signed.

Acte I — Interception (natif MCP). Aucune réécriture. EMILIA intercepte l'appel d'outil à la frontière du Model Context Protocol — au moment où un agent tente de supprimer un fichier ou de déplacer des capitaux, l'action est saisie au vol.

Acte II — Décision (liée à la politique, déterministe). L'action est vérifiée par rapport à une politique épinglée par hachage : allow, allow-with-signoff ou deny. Plus un mode observation qui ne change rien en production et rapporte ce qui aurait été retenu. Déterministe, auditable — pas une boîte noire de score de risque.

Acte III — La cérémonie (approbation humaine liée à l'appareil). Lorsque la politique exige un humain, EMILIA exécute une approbation WebAuthn / clé d'accès liée à l'action exacte — Face ID / Touch ID sur l'appareil propre de l'opérateur. Ce que l'humain a vu est ce qu'il a signé. Aucun script ne peut le falsifier ; aucune boucle autonome ne peut l'ignorer.

Acte IV — Le reçu (la preuve). Le résultat est un reçu d'autorisation signé que n'importe qui peut vérifier hors ligne, avec du code open source, sans backend, sans confiance envers un fournisseur. Altérez-le et la vérification échoue par construction. Ancrez-le optionnellement pour un horodatage public — le cœur n'a besoin d'aucune blockchain.

Pourquoi les développeurs l'utilisent

Vous voulez des agents qui font réellement des choses — mais vous êtes paralysé par les boucles incontrôlables, les dépenses excessives d'API et la destruction accidentelle de données. EMILIA vous offre un serveur MCP prêt à l'emploi + un wrapper SDK léger. Appliquez un hachage de politique, et les appels d'outils irréversibles gagnent une couche d'approbation et de preuve renforcée cryptographiquement, alignée sur le NIST AI RMF — sans avoir à construire des workflows d'approbation ou une infrastructure d'audit à partir de zéro.

# langchain-emilia — wrap any LangChain tool with an EP gate
from langchain_emilia import EmiliaGateClient

gate = EmiliaGateClient(base_url="https://www.emiliaprotocol.ai", api_key="...")
safe_tool = gate.wrap(your_destructive_tool)

pip install langchain-emilia   # PyPI
npm install @emilia-protocol/verify  # npm

Votre agent ne peut pas dépasser sa laisse.

Pourquoi les entreprises en ont besoin

Chaque changement de plateforme crée une nouvelle primitive de sécurité : le web a eu SSL, le cloud a eu Okta / IAM, l'économie des agents a besoin de confiance au niveau de l'action. Les entreprises sont assises sur des budgets IA que la conformité ne les laisse pas dépenser — EMILIA est la clé qui les débloque, en transformant des agents imprévisibles en une infrastructure prête pour l'audit, qui correspond primitive par primitive aux contrôles NIST AI RMF, EU AI Act et SOC 2 CC6/7.

La couche gérée (GovGuard / FinGuard) étend le standard ouvert avec des packs de politiques sectoriels, des pilotes en mode observation et des dossiers de preuves prêts pour l'audit — sans besoin d'approvisionnement pour commencer.

Le standard

EMILIA est un standard ouvert, pas une barrière de produit. Le cœur est sous licence Apache-2.0 et suivi en tant que brouillon Internet IETF.


Brouillons Internet IETF	Publiés : authorization-receipts · quorum. En préparation dans `standards/` : authorization-evidence-chain (EP-AEC, composition) · evidence-record (EP-EVIDENCE-RECORD, rétention à long terme). Cartographie du domaine : enquête de paysage.
Vérificateurs multi-langages	JavaScript · Python · Go — tous trois prouvés pour s'accorder sur des vecteurs de conformité adverses, à chaque envoi (`npm run conformance`). C'est la barre IETF pour un vrai standard : de multiples implémentations interopérables indépendantes.
Vérification formelle	26 propriétés de sûreté TLA+ (0 erreur) · 35 faits Alloy, 22 assertions — les deux exécutés en CI
Registres MCP	Registre MCP officiel · Glama (Grade A, badge Officiel) · Smithery
Licence	Apache-2.0

Trois implémentations indépendantes prouvées pour s'accorder — voir CONFORMANCE.md, ou vérifiez un reçu vous-même sur emiliaprotocol.ai/verify.

La pile EP

Eye observes. Handshake verifies. Signoff owns. Commit seals.

Couche	Ce qu'elle fait
EP Eye	Observe et classifie le comportement de l'agent (OBSERVE → SHADOW → ENFORCE)
EP Handshake	Cérémonie de consentement cryptographique avec liaison à 7 propriétés
EP Signoff	Propriété humaine nommée — WebAuthn / clé d'accès Classe A, liée à l'appareil ; quorum multipartite (M-sur-N / ordonné — la règle des deux personnes) pour les actions aux enjeux les plus élevés
EP Commit	Clôture d'action atomique et immuable avec reçus chaînés par Merkle

Points de preuve

Métrique	Valeur
Tests automatisés	4 220 à travers 173 fichiers
Propriétés de sûreté TLA+	26 vérifiées (T1–T26), 0 erreur — voir PROOF_STATUS.md
Assertions relationnelles Alloy	35 faits + 22 assertions à travers deux modèles — vérifiés en CI
Cas d'équipe rouge catalogués	85 — RED_TEAM_CASES.md
Résultats de sécurité corrigés	31
Conformité (7/7)	`node conformance/ep-conformance-test.js https://www.emiliaprotocol.ai`
Conformité multi-langages	8 suites — reçus · approbations d'appareil · quorum multipartite · révocation · attestation temporelle · reçu de confiance · provenance · enregistrement de preuve — les vérificateurs JS / Python / Go s'accordent (`node conformance/run.mjs`)
Handshake create p95	575ms à 50 VUs — PERFORMANCE_PROOF.md

Objets fondamentaux EP

EP standardise trois objets interopérables que toute implémentation conforme peut produire et vérifier :

Objet	Ce que c'est
Trust Receipt	Un enregistrement signé et portable d'un événement d'autorisation — ce qui s'est passé
Trust Profile	Un résumé standardisé de l'état de confiance observable — ce qui est connu
Trust Decision	Un résultat évalué par politique avec raisons et voie d'appel — que faire maintenant

Les extensions EP (Handshake, Signoff, Commit, Delegation) ajoutent une application plus stricte là où les systèmes doivent contraindre l'exécution. Les couches produit (GovGuard / FinGuard) sont construites par-dessus — pas le protocole lui-même.

Démarrage rapide en cinq appels

Créer une politique
Initier une poignée de main
Présenter une preuve
Vérifier
Signer et consommer

Démo de 90 secondes · Démarrage rapide · Procédure pas à pas pour agent · Brouillon IETF · Discord

Ce qu'est EP — et ce qu'il n'est pas

EP est l'autorisation au moment de l'action, pas un système d'identité, pas un portefeuille, pas un score de réputation.

Est : un standard de confiance pour lier l'identité de l'acteur, l'autorité, la politique et le contexte exact de l'action avant l'exécution
N'est pas : un remplacement pour OAuth / OIDC (ceux-ci répondent à qui êtes-vous — EP répond à qui a approuvé cette action exacte)
N'est pas : un produit propriétaire (le cœur est sous Apache-2.0 et suivi par l'IETF)
N'est pas : une blockchain (le reçu est le héros ; l'horodatage public optionnel est une note de bas de page)

Voir CONFORMANCE.md · SECURITY.md · THREAT_MODEL.md · GOVERNANCE.md