EMILIA Protocol

AI agents are becoming workers. Workers need authority.

EMILIA is the authority control plane for autonomous work. Gate is the consequence boundary where an agent's credentialed intent becomes a change to money, code, permissions, records, or infrastructure. A human or institution defines a finite operating mandate; Gate checks the exact unit of work against it before the protected provider path can begin.

Gate is the commercial Consequence Firewall on that boundary. It verifies the authority the owner requires for the exact action, reserves that authority before provider entry, permits one admitted provider attempt for the covered authorization instance within its durable authority domain, and leaves portable evidence of what the protected path admitted and later observed. When the result is unknown, it requires reconciliation instead of a blind retry. Protocol proves. Gate prevents.

• Authority Brain maps supported declared action surfaces locally. No account, upload, or callback is required. Discovery creates no authority; the owner reviews the map.
• EMILIA Gate turns the approved map and operating mandate into preventive control on a fully mediated, credential-owning executor path.
• EMILIA Protocol is the open Apache-2.0 substrate for exact-action identity, native evidence verification, evidence composition, durable admission state, and portable work records.
• EMILIA Approver captures a device-bound exact-action human decision when the mandate or local policy requires fresh human authority. A human click is one authority source, not the default execution model.
• EMILIA Assurance Plane provides scoped verification, re-performance, conformance reports, and deployment evidence. It supports auditors, insurers, regulators, and customers; EMILIA is not an auditor or accredited certifier, and no public EMILIA certification program is operating.

Run the local map (npx @emilia-protocol/scan), choose one consequential workflow, and place Gate where the provider credential turns intent into work.

The first low-friction distribution profile is GitHub: the open Merge Gate binds a repository-owned mandate and detached receipt to the exact base and head commits before a protected merge check passes. It is preventive only when the repository makes the check required and closes alternate merge paths. This is a product and distribution experiment, not evidence of external adoption.

The agent may keep running. Its authority stops.

Continuous and self-improving agents create a control problem that process termination alone cannot solve: the owner may need to stop new consequences without claiming that computation stopped or that an external effect was reversed. Gate's Emergency Authority Freeze makes that a durable authority transition. Inside a covered Gate control domain, freeze blocks new reservations and prevents an older reservation from entering after the control epoch changes. If provider entry serialized first, the operation remains consumed and must be reconciled; restore advances the epoch again and does not revive old authority.

This guarantee requires complete mediation and authoritative shared state. It does not stop the agent, undo an entered effect, or provide instant freeze across a disconnected leased domain. The current reference implementation covers the local in-memory and PostgreSQL control domain; leased-edge propagation and portable signed freeze-event evidence remain explicit implementation gaps.

The named paid workflow remains payer AI-assisted adverse medical-necessity determination, under one safety rule: no valid licensed-review evidence, no adverse determination. Missing evidence routes to lawful human review or a patient-protective fallback; it is not authority to withhold medically necessary care.

AI systems and repository reviewers: start with AI_CONTEXT.md. Current machine-readable evidence, provenance, assumptions, and exclusions are published at EMILIA-REPO-CONTEXT-v1. Archived or staged documents do not establish current implementation or IETF status. Public due-diligence evidence and claim boundaries: DUE_DILIGENCE.md.

Engineering evidence, not architecture claims

EMILIA ships a security case that reviewers can execute. The current repository resolves 35 security claims over 259 hashed evidence files, verifies 20 Tamarin lemmas across two composed Dolev-Yao models — 17 all-traces obligations and 3 exists-trace reachability witnesses — and preserves 8 deliberately weakened variants that produce concrete attack traces when load-bearing checks are removed. The live same-team conformance corpus contains 21 suites and 331 current vectors. Separately, an externally authored Rust verifier is pinned to the frozen 16-suite/164-vector bundle and a 359-case hostility campaign. The broader suite contains 9,104 automated tests across 563 files.

Production JavaScript and JSDoc surfaces are compiler-checked with TypeScript checkJs; the secure app has its own compatibility compiler project, while declarations and the public TypeScript SDK are checked in strict mode. This is complete configured production type-check coverage, not a claim that the repository was converted wholesale from JavaScript to TypeScript or that every JavaScript project has TypeScript's strict option enabled.

Each security claim names the enforcement path, positive and negative vectors, language coverage, formal scope or explicit gap, assumptions, exclusions, and evidence hash. Start with the human-readable evidence map, then inspect the resolved security case or run npm run check:security-case.

AEB-1: test the evidence-to-effect boundary

The open AEB-1 Consequence Admission Conformance pack tests the last control point before a consequential action: native verification, relying-party acceptance, exact CAID/action matching, evidence satisfaction, local authorization, atomic reservation, INVOKING custody, separate provider-outcome and observed-effect truth, no-blind-retry behavior, and authenticated reconciliation.

npx @emilia-protocol/verify aeb-conformance --reference

It is format-neutral and self-run. A passing report is self-attested conformance evidence—not an audit, certification, production-deployment claim, or permission to execute an action.

For a focused executable proof of the repository's Gate path, run:

npm run proof:gate:reference

This command exercises local examples and focused service boundaries with generated keys, in-memory state, and mock provider behavior. It is useful local proof, not evidence of a real human, external bank, production deployment, or one end-to-end production integration.

Identity is not a job description

Identity says who or what is calling. Policy says what is generally allowed. Neither defines the finite job an autonomous worker may perform now: its mission, material-action limits, budget, required evidence, expiry, delegation rules, and exception path.

EMILIA keeps those questions separate:

Credentials grant reach. Authority defines the job. Not every action needs a human; every consequential action needs valid authority.

At the foundation, EP Core still exposes three interoperable objects: a Trust Receipt carries attributable evidence, a Trust Profile represents structured trust state, and a Trust Decision records the relying party's policy-evaluated result. The authority-control-plane layers add exact action binding, finite mandates, admission, consumption, and outcome evidence without collapsing those objects into one claim.

Set the mandate once. Let the agent work.

The customer defines the mission, limits, evidence requirements, expiry, and exception rules. Local code may narrow that authority; it cannot invent or widen it. Gate binds each executable request to the mandate, reserves the covered authority before provider entry, permits one admitted provider attempt for that authorization instance inside the shared durable authority domain, and escalates only when authority is missing, stale, exhausted, or too narrow.

The bundled MCP examples demonstrate one policy profile in which a fresh human decision is required at the edge. They run the complete local loop—missing evidence refused, exact action signed, one provider attempt admitted, forged evidence rejected—without claiming that every autonomous action needs a human click:

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

The deeper composition demo executes a CAID-bound delegated payment through Gate's real bounded-capability path, then verifies the signed execution certificate offline:

npm run demo:receipt-program

It deliberately includes no blockchain or simulated zero-knowledge claim. See the receipt-program architecture for the production state and trust requirements.

Start with a dry run against your declared tool surface, then generate the reviewable integration files:

npx @emilia-protocol/scan protect ./tools.json
npx @emilia-protocol/scan protect ./tools.json --apply
node emilia/verify-setup.mjs

The generated local check uses explicitly ephemeral demo state and proves only that its synthetic handler was not called. Production requires a durable provenance ledger, a shared atomic consumption store, pinned keys, and the wrapper on every path to the real provider credential. See examples/mcp/ and /mcp.

Try it in 30 seconds

# 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

Try a real Face ID signoff → Approve an $82,000 wire with your own passkey. See what VERIFIED looks like. Forge the receipt. See it fail.

Verify any receipt in your browser — paste it in, nothing is uploaded.

How it works — one authority lifecycle

Run it yourself: node examples/crash-test.mjs — fully offline, no API key.

  [ MANDATE ]       [ EXACT WORK ]       [ VERIFY ]       [ RESERVE + ENTER ]  [ RECONCILE ]
  mission, limits   canonical action     pinned native    one admitted        preserve provider
  evidence, expiry  + occurrence         evidence         provider entry      and effect truth

Mandate. The authority source defines finite work. It can be a customer-signed operating program, bounded capability, required human decision, quorum, or a relying-party composition of native evidence.

Exact work. Gate binds method, origin, callee, target, occurrence, and every material field into the canonical executable object. Intent, a prompt, or ticket text is not that object.

Verify, reserve, and enter. Native artifacts remain native. The relying party pins trust and mapping profiles, evaluates the complete evidence requirement, makes the separate local authorization decision, and reserves the covered authority before the credential-owning adapter enters the provider.

Fresh human authority when required. A policy can require a WebAuthn/passkey decision bound to the exact action and deterministic display hash. This narrows the “what you saw is what you signed” gap; it does not prove comprehension, wisdom, legality, or outcome.

For enterprise deployments, Gate can additionally require an independently verified Authorization Server confirmation bound to that exact human evidence, the same exact action, the identity snapshot the AS actually observed, and the intended Resource Server key. The snapshot time and relying-party maximum age are explicit: a fresh token cannot make stale directory data current. The AS leg is evidence under customer-pinned trust; it never authorizes by itself, proves instantaneous employment standing, or turns the agent orchestrator into an authority.

Truthful result. Admission is not execution, and execution is not effect. A signed record can be verified offline; provider and observer evidence remain separate. A lost response becomes INDETERMINATE, which is a state to reconcile—not permission to retry. A remedy is a new authorized action and never rewrites the old result.

Why developers use it

Start by mapping the work locally, then protect one declared action surface with the MCP server or thin SDK wrapper. The scanner proposes a reviewable map; the owner defines the mandate; Gate owns the provider credential and enforces the exact action on the covered path. No scan proves complete mediation, and discovery alone grants no authority.

# 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

The agent receives the ability to perform bounded work, not a standing credential it can reinterpret.

Why enterprises need it

Agent processes restart and models change. The customer's mandate, consumption state, revocation, uncertainty, and work history must survive outside them. EMILIA keeps that durable authority state at the customer's boundary while accepting foreign proof through pinned adapters.

The managed Gate and Assurance Plane add mandate operations, integrations, evidence operations, re-performance, support, and service levels around the open protocol. The customer retains control of authority, trust roots, credentials, policy, and portable evidence.

The standard

EMILIA Protocol is open and Apache-2.0. Its standards work is published as a portfolio of individual Internet-Drafts. A published Internet-Draft is not an RFC, an adopted working-group item, or IETF endorsement; Datatracker is authoritative for revision and status.

Canonical four-document presentation surface

For reader navigation, the canonical evidence path is:

1. Authorization Receipts-11 defines the action-bound approval-evidence profile. The current posted revision is -11, filed as a Standards Track candidate individual submission.
2. Human Authorization Binding-00 binds a named-human authorization artifact into an adjacent host record.
3. Authority Introduction-03 establishes relying-party-pinned trust roots and scoped authority.
4. Authorization Evidence Chain-05 evaluates whether natively verified, action-matched evidence satisfies the relying party's requirement; it returns SATISFIED or UNSATISFIED, never AUTHORIZED.

This four-document surface is presentation only. It does not merge, retire, replace, update, obsolete, subordinate, or demote any draft in the active portfolio.

Separate runtime execution spine

The runtime path is Architecture-02 → CAID-02 → AEC-05 → AEB-03: system boundaries, exact material-action matching, evidence satisfaction, then executor-side admission and durable consequence custody. AEC appears in both views because evidence satisfaction feeds runtime admission, not because the views are equivalent.

The complete active portfolio remains 23 Datatracker records: 20 active draft-schrock-* records and three coauthored records, each with its own scope and revision history. See the standards guide, portfolio, and machine-readable status inventory.

Three same-team reference ports (JS / Python / Go) agree across all 21 suites and 331 vectors. Separately, an externally authored Rust implementation rebuilt from a pinned public source tree passes the pinned 16-suite/164-vector clean-room bundle and a 359-case hostility campaign, re-run in its own CI lane on every change. The newer AEC acceptance and four-outcome resolution suites are not attributed to Rust. That is external interoperability evidence, not strict clean-room construction acceptance; the aggregate CI case records the strict acceptance count as zero pending independent attestation. See CONFORMANCE.md, or verify a receipt yourself at emiliaprotocol.ai/verify.

The authority stack

Proof points

Core protocol objects

Quickstart

1. Run npx @emilia-protocol/scan protect ./tools.json to map supported declared surfaces.
2. Review the generated action manifest, material fields, credentials, and named blind spots.
3. Install Gate on the path that owns the provider credential and durable consumption state.
4. Define the operating mandate and any fresh-human or quorum exception rules.
5. Run the refusal, exact-action, replay, timeout, and reconciliation cases before enabling enforcement.

90-second demo · Quickstart · Agent walkthrough · IETF Draft · Discord

What EP is — and is not

EMILIA is authority infrastructure for autonomous work, not an identity system, wallet, reputation score, settlement rail, or universal policy engine.

• Is: a control plane for finite operating mandates, exact-action verification, durable admission state, truthful uncertainty, and portable evidence on covered executor paths.
• Is not: a replacement for OAuth/OIDC, workload identity, or policy engines. Those remain native inputs under the relying party's pins.
• Is not: a requirement that a human approve every action. A mandate may permit automatic work inside finite bounds and demand fresh authority only at the edge.
• Is not: proof that an admitted action executed successfully or caused the intended effect.
• Is not: proprietary protocol control. The core is Apache-2.0 and the Internet-Drafts are individual submissions, not RFCs or IETF endorsement.

See CONFORMANCE.md · SECURITY.md · THREAT_MODEL.md · GOVERNANCE.md · Neutrality Covenant