Universal Ideal Standards & Universal Interaction Platform — UIS / UIP v0.1.0
A constitutional doctrine of the ecosystem: what should conform, and how conforming systems interact — standards that define correctness, protocols that achieve it, and a constitutional lifecycle that keeps them apart.Status: ❄️ Frozen (2026-08-03) — freeze gate met: interop-profile v0.1.0 conformance suite 22/22 green (UIP-1..5) via UCFActions interop-conformance, attestation aaa001bbdd86bfb09d9a61305841a794999472071da982edfd7efa11ae047de9; CodeLab (USE gate) 10/10 via codelab-conformance, attestation 20a3cf6b2a2080f5… Constitutional dependencies: USCP (six primitives) · URS v0.1.0 (specs.initialcore.net/urs.html) · CORE-LD v0.1.0 · UAM v0.2.0 (specs.initialcore.net/uam.html) · USE v0.1.0 (specs.initialcore.net/use.html) Scope: The entire ICore ecosystem — every standard, protocol, implementation, and conformance exercise Registry prefixes: UIS · UIP
# Part I — The Doctrine
1. The Constitutional Lifecycle
ICore is not a collection of technologies — it is a constitutional lifecycle. Every layer answers a distinct constitutional question, and together they form a continuous pipeline from first principles to trustworthy operation:
| Constitutional question | Layer | Existing instance |
|---|---|---|
| What must always be true? | **USCP** (Universal Sovereign Constitutional Principles) | The six primitives |
| What should conform? | **UIS** (Universal Ideal Standards) | URS, CORE-LD family, UAS, USDS |
| How is it represented? | **URS** — canonical representation, spanning the lifecycle | URS v0.1.0 (23 invariants) |
| How do conforming systems interact? | **UIP** (Universal Interaction Platform) | UCN substrate, libisp, LD payload semantics |
| What should be selected or decided? | **USE** (Universal Selection Engine) | USE v0.1.0 (USE-1..6) |
| How are constitutional artifacts forged? | **UCF** (Universal Constitutional Forge) | Forge, attestation, registry |
| How are they executed consistently? | **USR / CoreFab** | CoreFab runtime |
Build around constitutional responsibilities, not technological dependencies. Technologies become replaceable implementations; the constitutional pipeline remains stable.
2. UIS — What Should Conform
UIS defines the ideal specifications and conformance targets derived from the principles. Standards define what is correct: data models, representations, APIs, security, interoperability, conformance criteria. URS, the CORE-LD family, UAS, and USDS are UIS instances — each a specification of what a conforming artifact is.
Standards evolve slowly. A standard changes only by constitutional process — versioned, never rewritten. Stability is the point: the deeper the layer, the slower it moves.
3. UIP — How Conforming Systems Interact
UIP governs interaction — exchange, negotiation, synchronization, verification, coordination. Protocols define how correctness is achieved during interaction. UIP is the Universal Interaction Platform: the constitutional interaction layer, independent of any transport, runtime, language, or network.
- libp2p is one UIP transport profile (the UCN substrate).
- QUIC, WebRTC, WebTransport are future transport profiles.
- UIP itself never changes when a transport changes.
The most valuable lesson from the networking ecosystem, elevated into a constitutional principle:
**One constitutional specification → Multiple implementations → Shared conformance → Guaranteed interoperability.**
This is more general than libp2p: it applies to every ICore layer, and the kernel already executes it — cross-implementation tests (21 green) prove interop by shared conformance, not identical code.
4. The libp2p Boundary — Already Drawn
libp2p standardizes communication; ICore standardizes trustworthy intelligence. libp2p leaves meaning, identity semantics, constraints, policies, trust, proofs, decisions, knowledge, memory, reasoning, execution, and governance to the application. Those are precisely the layers ICore already occupies: URS/CORE-LD (meaning), UAS (identity), TRUST-LD/POLICY-LD (trust and policy), MEMORY-LD (memory), USE (decision), UAM (application governance). Networking is one interchangeable implementation beneath constitutional intelligence — never a dependency of it.
5. Evolution Rates — the Ecosystem Discipline
| Layer | Evolves | Boundary discipline |
|---|---|---|
| Principles (USCP) | Rarely | Principles never prescribe implementations |
| Standards (UIS) | Slowly, by constitutional process | Standards never prescribe protocols |
| Protocols (UIP) | When interaction patterns change | Protocols never prescribe languages or runtimes |
| Implementations | Rapidly | Always replaceable; never elevated to requirements |
| Conformance (UCF) | Stable, measurable | Objective and machine-verifiable |
This is the same philosophy behind the Internet (IETF), the Web (W3C), and Unicode — applied through a constitutional lens. Strict about outcomes, tolerant about methods: the ecosystem can evolve for decades without accumulating complexity or technology lock-in.
# Part II — The Specification
1. Classification
UIS instances (standards — what should conform): URS, CORE-LD family (INPUT/MEMORY/POLICY/TRUST-LD, JSON/CBOR bindings, canonicalization), UAS, USDS. Each declares its derivation chain and conformance suite.
UIP instances (protocols — how systems interact): UCN substrate (libp2p profile), libisp (sovereign protocol, ConstitutionalLog), LD payload semantics over any transport. Each declares its transport profile and interoperability tests.
New artifacts are classified at minting: a standard enters the UIS registry; an interaction rule enters the UIP registry; anything else is an implementation, a preference, or a proposal.
1a. Taxonomy: Roles, Not Nouns
Do not standardise nouns; standardise architectural roles. A new artifact is minted only if it names a constitutional role, not a domain entity. Classification follows three levels:
| Level | Character | Examples |
|---|---|---|
| **1 — Foundational** (few, stable) | Encodings and canonical forms every standard rests on | URS · CORE-LD (JSON/CBOR) · DAG-JSON-LD / DAG-CBOR-LD codecs |
| **2 — Universal roles** (only if constitutionally fundamental) | Roles the Verify→Select→Execute triad requires | INPUT-LD (minted) · OUTPUT-LD / PROCESS-LD (deferred until a conformance suite needs them) |
| **3 — Domain profiles** (many, optional) | Reusable semantics for a domain; never foundational | Event-LD, Agent-LD, Workflow-LD, Knowledge-LD, Identity-LD — none minted; each earns elevation only by a running conformance suite |
Elevation by conformance, not taxonomy. Naming a profile "universal" elevates nothing; a suite that runs green against it does. TRUST-LD / POLICY-LD / MEMORY-LD are domain profiles by name but load-bearing by execution — CodeLab's conformance suite runs against them. A profile without a conformance suite is a proposal (UIS-2).
Events. Event-LD, CBOR-Event-LD, and DAG-Event-LD are plausible but not foundational. They are not minted: URS does not yet declare whether an Event is a primitive or a derived kind, and MEMORY-LD already carries event semantics (CodeLab episodes: occurrence, actor, sequence, rationale, outcome). Should URS declare Event fundamental and a second conformance suite require distinct event semantics, Event-LD is the semantic profile, CBOR-Event-LD and DAG-Event-LD its serialization variants — never the reverse.
2. UIS Invariants
| # | Invariant | Mechanical verification |
|---|---|---|
| UIS-1 | **Derivation.** Every standard traces through the constitutional chain (USCP → … → its layer) and declares its position. | Derivation table present in the standard's record (UCF) |
| UIS-2 | **Conformance targets.** Every standard defines machine-verifiable conformance criteria; a standard without a conformance suite is a proposal. | Conformance suite exists and runs green |
| UIS-3 | **Standards do not prescribe protocols.** A standard specifies what conforms; it never mandates how interaction occurs. | No transport/language/runtime mandate in standard text (CCA §4 check) |
| UIS-4 | **Stability by process.** Standards change only by versioned constitutional process — never by rewrite. | Version history; prior versions remain attested |
3. UIP Invariants
| # | Invariant | Mechanical verification |
|---|---|---|
| UIP-1 | **Transport independence.** The interaction layer is independent of any transport, runtime, language, or network. | Transport profiles declared; core layer has no transport import |
| UIP-2 | **One spec, many implementations.** Each UIP protocol has one specification and at least two independent implementations with shared conformance. | Cross-implementation suite green (kernel `cross-implementation`, 21 tests) |
| UIP-3 | **Interoperability by conformance.** Interop is guaranteed by shared conformance, never by identical code. | Interop exercised via conformance, not code sharing |
| UIP-4 | **Meaning on the wire.** Constitutional interaction carries constitutional meaning: payloads validate against URS/CORE-LD before action. | Payload validation precedes any protocol action (USE-1 chain) |
| UIP-5 | **Protocols do not prescribe runtimes.** Implementations remain replaceable adapters. | Adapter boundary declared; substitution demonstrated (UAM-6) |
4. Four-Question Stress Test (condensed)
| Claim | What invariant | How verified | If absent |
|---|---|---|---|
| Standards define correctness | UIS-1, UIS-2 | Conformance suites green | Standards become opinions |
| Protocols achieve correctness | UIP-3, UIP-4 | Cross-impl + payload validation | Interop becomes faith |
| Transport independence | UIP-1 | Profile registry, no core imports | Lock-in to a network stack |
| Evolution-rate separation | UIS-3, UIP-5, UIS-4 | Boundary checks at minting | Complexity and lock-in accumulate |
5. Freeze Gate
UIS/UIP v0.1.0 flips Doctrine → Frozen upon the first external UIP conformance exercise — the W3C DID/VC interop profile — running green against UIP-1..5, together with the CodeLab (USE's gate). Claim discipline holds: self-conformance certifies internal consistency; external review certifies nothing until it runs.
Gate met — 2026-08-03
| Requirement | Evidence |
|---|---|
| External UIP conformance exercise | `interop-profile` v0.1.0 (did:key resolution, VC 2.0 Data Integrity Ed25519Signature2020, VC-JOSE-COSE, shared vectors) — 22/22 green |
| UIP-1..5 mechanically verified | `uip::run_uip_conformance()` — transport-free deps (UIP-1), shared vectors (UIP-2), conformance-not-code interop (UIP-3), payload validation precedes action (UIP-4), CAL provider registry consumed (UIP-5) |
| UCF attestation | UCFActions `interop-conformance` 4/4 steps, chain `aaa001bbdd86bfb09d9a61305841a794999472071da982edfd7efa11ae047de9` (report-interop-conformance-1785819125235.json) |
| CodeLab (USE gate) | `codelab-conformance` 4/4 steps, chain `20a3cf6b2a2080f5…` (report-codelab-conformance-1785758118999.json) |
| Full tree | `automation/test-all.sh` 394/394 green (incl. interop-profile 22 + codelab 10) |
UIS/UIP v0.1.0 is therefore Frozen — its invariants are attested by execution, not assertion. Scope boundary: the interop profile proves W3C wire-shape conformance (did:key, VC 2.0, Data Integrity, VC-JOSE-COSE) and UIP-1..5 internally; URDNA2015/RDFC-1.0 byte-level canonicalization equivalence is the T2 (CBOR-LD) thread's gate, tracked separately.
End of UIS/UIP Doctrine v0.1.0 — August 2, 2026. ❄️ Frozen 2026-08-03 — interop profile v0.1.0 (UIP-1..5, 22/22, attestation aaa001bbdd86bfb09d9a61305841a794999472071da982edfd7efa11ae047de9) + CodeLab (USE gate, 10/10). Derives from USCP + URS v0.1.0 + CORE-LD v0.1.0 + UAM v0.2.0 + USE v0.1.0.