ENC Pipeline
The ENC Pipeline is the toolchain that makes the protocol, its implementations, and the apps built on it one artifact in many forms — each derived from a single formally-verified specification and cryptographically linked to the others. It's how "the spec runs" (see the litepaper): humans write intent, agents resolve it to math, and every downstream form is a verifiable derivation rather than a hand-written translation.
Not yet open source. These tools are being prepared for open release. This section documents how they work — the architecture and the soundness arguments — not how to use them; there is no install or public API yet.
The spine is four meta-protocols, plus three runtime tools the app layer builds on:
| Tool | Role |
|---|---|
| SpecGen | The framework — turns human intent into a checked Lean spec, a green release gate, and a signed report anyone can re-verify |
| CodeGen | Emits every implementation (Lean reference, JS SDK, JS node, Rust/WASM kernel, Cloudflare Worker) byte-deterministically from the spec |
| AppGen | Turns app intent into a formally-specified app from a closed vocabulary of verified building blocks, across 11 platforms |
| TestGen | Proves every app's every workflow conforms across a platform matrix — the operational discharge of the "matrix theorem" |
| ENC Emulator | A browser testbed that runs every app against a real node across the full tier matrix; a required release witness |
| ENC UI Kit | An algebraic, manifest-driven UI layer whose state operations are proven to refine a Lean algebra |
| ENC Flow | The enclave-resolution engine that turns UI + flow config into the canonical AppSpec the rest of the pipeline consumes |
The spine
intent → SpecGen → CodeGen → AppGen → TestGen
│ │ │
└─ Flow ─ UI Kit ─ Emulator (app-layer runtime tools)
SpecGen makes the spec the canonical artifact; CodeGen derives the protocol's implementations from it; AppGen derives whole apps the same way; TestGen proves the result conforms on every platform. Flow, UI Kit, and Emulator are the app-layer tools generated apps run through — declarative app definition (Flow), algebraic UI (UI Kit), and the cross-platform testbed (Emulator).
Why it exists
A normal protocol ships through a chain of vibe-coded translations — prose → SDK → ports → CI
→ publish → deploy — where every arrow can silently disagree. None of the usual tools
(typecheckers, unit tests, npm audit, signed commits) says the one thing that matters: the
production deployment realizes the human spec. The pipeline collapses that chain — each form is
generated and checked against the one above it — so that statement becomes a property you can
verify, not a hope.
This is the "agents build for agents" thesis from the litepaper made concrete: agents can't be trusted to write correct systems, but they can build the machinery that makes systems verifiable.