Status: live Updated: 2026-11-21 Category: Standards Track
Credentials are W3C Verifiable Credentials (Data Model 2.0) secured by a
DataIntegrityProof using the eddsa-jcs-2022 cryptosuite, with revocation
and suspension through Bitstring Status Lists (§14). §14 is the only credential
path. Credential status is issuer-bound (§5.3). Cardano carries optional VC
integrity anchors (§11.3), the completion witness (§5.1), stake-key
registrations (§3.1) and batched username anchors (§6.5); the DAO validators
are deployed, but no application path submits governance transactions (§10.5).
Decision records: adr/0001-vc-first-credentials.md,
adr/0003-credential-authority.md,
adr/0006-checkable-integrity-evidence.md,
adr/0007-did-key-never-rotates.md and
adr/0008-hosted-organisation-issued-credentials.md.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.
The following terms are used throughout this specification:
- Subject Field — A top-level domain of knowledge (e.g. "Computer Science", "Mathematics").
- Subject (taxonomy) — A discrete area of study contained within a Subject Field (e.g. "Distributed Systems", "Linear Algebra"). Used in §4, §5, §8, §10.
- Subject (credential) — In the §14 Verifiable Credentials Protocol, the entity about whom a claim is made, identified by a DID (see §14.4.1). Matches the W3C
credentialSubjectrole; disambiguated from the taxonomy sense by surrounding context. - Skill — An atomic, assessable unit of competence within a Subject. Skills form a directed acyclic graph (DAG) with explicit prerequisite edges.
- VerifiableCredential — A W3C-style signed credential issued under §14. Carries a claim about a subject, bound to an issuer DID, verifiable without Alexandria infrastructure.
- Issuer — In §14, the authority that signs and originates a credential. Exactly one primary issuer per credential (§14.4.2).
- ReputationAssertion — A computed, credential-derived score for an actor in a role, scoped to a skill and proficiency level (§4). Distinct from the §14.14 Derived Skill State, which aggregates a subject's evidence for one skill.
- DerivedSkillState — The explainable output of the §14 trust aggregation pipeline: (rawScore Q, confidence C, trustScore T, level L, evidenceMass M, uniqueIssuerClusters U) for a (subject, skill) pair.
- DAO — Decentralised Autonomous Organisation; a governance body responsible for decision-making within a defined scope.
- ProficiencyLevel — An ordered enumeration of learner capability within a Skill, based on Bloom's Taxonomy:
remember,understand,apply,analyze,evaluate,create. - Node — A running instance of the Alexandria application (desktop or mobile), containing a complete database, content store, P2P networking stack, and wallet.
- Sentinel — The client-side assessment integrity system that monitors behavioral signals during assessments.
For motivation, design rationale, and stakeholder context, see the companion document: Alexandria: Free Knowledge, Verified Skills, No Gatekeepers.
This specification defines the data models, verifiable credentials, reputation mechanics, query interfaces, governance structures, decentralisation requirements, peer-to-peer protocol, course completion, assessment integrity, and threat mitigations for the Alexandria protocol. It is intended as a normative reference for implementors, contributors, and governance participants.
Alexandria is a Tauri v2 application — a single binary that bundles a Rust backend with a Vue 3 frontend. Every user runs a full node. There is no application server, no Docker container, and no external database. Relays assist peer discovery and NAT traversal; they hold no application state and cannot read the traffic they forward (see §6.1).
All state lives on the user's device in three locations:
| Store | Purpose |
|---|---|
| Profile index | Format-version-2 public sidecar profiles_index.json — immutable network IDs, display names, and avatars only (no crypto material). Rendered by the picker before any vault is unlocked. |
| SQLite | Per-profile relational data (courses, skills, interviews, governance, verifiable credentials) across 27 migrations. One DB per profile at profiles/<uuid>/alexandria.db. |
| Encrypted vault | Per-profile wallet keys and mnemonic — IOTA Stronghold (desktop) or AES-256-GCM + Argon2id (mobile). One vault per profile under profiles/<uuid>/vault/. |
| iroh | Per-profile content-addressed blobs (course HTML, profiles) — BLAKE3 hashes. One blob store + node secret per profile at profiles/<uuid>/iroh/. |
The architecture MUST satisfy:
- Offline-first: Every operation MUST work without network access. Sync is opportunistic.
- Self-sovereign identity: The user's 24-word BIP-39 mnemonic IS their account. No email, no password recovery service, no OAuth provider.
- Trustless verification: Credentials anchored on Cardano MUST be independently verifiable without contacting the platform.
- Privacy by architecture: Raw behavioral data (Sentinel) MUST NOT leave the device. Only derived scores MAY cross the network.
| Layer | Technology |
|---|---|
| Shell | Tauri 2.10, WebKit (macOS/iOS) / WebView2 (Windows) / Android WebView |
| Backend | Rust (2021 edition), tokio async runtime |
| Frontend | Vue 3, TypeScript, Vite, Tailwind CSS v4 |
| Database | SQLite (rusqlite, bundled) |
| Content storage | iroh 1.0.2 / iroh-blobs 0.103 (BLAKE3 content-addressed blobs) |
| P2P networking | libp2p 0.56 (TCP, QUIC, GossipSub, Kademlia, Relay, DCUtR) |
| Wallet (desktop) | BIP-39 + CIP-1852 (pallas), per-profile IOTA Stronghold vault |
| Wallet (mobile) | BIP-39 + CIP-1852 (pallas), per-profile AES-256-GCM + Argon2id vault |
| Cardano | pallas 0.35 (Conway tx builder), Blockfrost preprod |
The frontend communicates with the Rust backend through Tauri IPC commands registered in tauri::generate_handler!. Commands are split across domain-facing modules including profile, settings, classroom, governance, taxonomy, tutoring, interview, identity, credentials, sync, courses, attestation, opinions, integrity, content, pinning, storage, snapshot, reputation, enrollment, elements, chapters, catalog, P2P, aggregation, presentation, health, guardian, instructor, completion, pairing, assessment, goal templates, skill bootstrap, content governance, role assessment, Sentinel, updater, users, and username registry. CI (scripts/check-tauri-commands.mjs) fails if any command in scripts/retired-tauri-commands.json (credential challenge, escrow, plugin-attestation ingest/status, local DAO/election/proposal authority) is registered, invoked, or allowlisted. The profile module owns the multi-user lifecycle (list_profiles, create_profile, restore_profile_with_mnemonic, unlock_profile, lock_profile, rename_profile, set_profile_avatar, delete_profile, get_active_profile_id); the identity module is reduced to operations against the active profile (export_mnemonic, is_biometric_available, get_wallet_info, get_local_did, get_profile, update_profile, publish_profile, resolve_profile); the settings module owns the unified per-profile preference store (list_settings, set_setting, reset_setting), with scope='sync' rows propagated across the user's other devices via the existing cross-device sync (LWW on updated_at). Interview records are local application state rather than a normative Alexandria gossip protocol; see interview-assistant.md.
24-word BIP-39 mnemonic
|
v
BIP32-Ed25519 master key (Icarus / CIP-1852 via pallas-wallet)
|
+-- m/1852'/1815'/0'/0/0 --> payment key (signing + verification)
| +-- bech32: addr_test1...
| +-- GossipSub envelope signing key
| +-- DID-key signing material (VC §14.5)
| |
| +-- HKDF(payment_key, device_id)
| +-- per-device libp2p Ed25519 keypair
| +-- PeerId: 12D3KooW...
|
+-- m/1852'/1815'/0'/2/0 --> stake key
+-- bech32: stake_test1...
+-- signs `stake_pubkey_registration` txs
(binds stake addr → gossip pubkey)
The payment key MUST serve as: (1) Cardano payment signing key, (2) GossipSub envelope signing key, (3) content/profile document signing key, and (4) DID-key signing material for the VC layer. The libp2p peer identity is intentionally not the payment key — it is derived per device via HKDF(payment_key, device_id) so the same mnemonic restored onto multiple devices produces distinct PeerIds. The stake key signs the stake_pubkey_registration transactions that anchor a stake address's gossip-envelope public key on chain (see docs/stake-pubkey-registry.md).
Keys MUST be stored in a per-profile encrypted vault under <app_data>/profiles/<uuid>/vault/. Each profile owns an independent vault; compromising one profile's vault MUST NOT expose any other profile on the same device. The implementation varies by platform:
Desktop (IOTA Stronghold): Password → Argon2id (64 MB, 3 iterations, 4 lanes) with random salt → derived key. Salt file includes HMAC-SHA256 integrity tag. Mnemonic stored encrypted at a fixed vault path.
Mobile (Portable AES-256-GCM + Argon2id): Password → Argon2id (64 MB, 3 iterations) → 256-bit key. Mnemonic encrypted with AES-256-GCM (random 96-bit nonce). Vault file contains salt + nonce + ciphertext.
Both platforms MUST enforce a minimum 12-character password. The Wallet struct MUST implement Drop with zeroization; Clone MUST NOT be derived.
Newly-created persistent entity IDs MUST be computed as hex(blake2b_256(parts.join("|"))) (see crypto::hash::entity_id) rather than server-generated UUIDs. This ensures deterministic, collision-resistant identifiers derived from entity properties, gives the gossip mesh free dedup, and lets a verifier re-derive an id from the underlying inputs.
The VC layer follows a versioned variant: a credential's id is
urn:alexandria:vc:<hex> where <hex> is entity_id(["vc:v1", issuer_did, subject_did, claim_kind, blake2b(JCS(claim)), valid_from, status_list_id, status_list_index]) (see domain::vc::id::deterministic_credential_id). The status-list slot guarantees uniqueness across legitimate re-issuance of the same claim for the same subject.
Presentation envelopes and PinBoard commitments still allocate urn:uuid: ids; they SHOULD move to deterministic ids before public launch.
For the DID identity model used by the verifiable credentials layer (§14), see §14.5. A did:key always resolves to the key in its identifier; there is no personal key rotation (§14.5.3). The wallet-level key derivation defined in §3.1 supplies the underlying Ed25519 signing material; the VC layer binds a did:key identifier to that same key by multicodec-wrapping the Ed25519 public key (varint 0xed01) and encoding it as multibase base58btc.
Reputation is a computed, skill-scoped view of an actor's record, derived from verified credentials (§14). It is not a credential, not a global score, and not platform-owned.
The Reputation System MUST:
- Be derived solely from credentials that verify at computation time (§14.13).
- Be scoped to a specific Skill and ProficiencyLevel.
- Be role-specific (e.g. instructor vs learner).
- Be reproducible from disclosed evidence.
- Avoid global or identity-wide scalar scores.
The Reputation System MUST NOT:
- Assign reputation without evidence.
- Aggregate across unrelated skills.
- Override learner ownership controls.
- Depend on platform-specific trust assumptions.
Reputation MUST always be defined over the following tuple:
(subject, role, skill, proficiency_level)
Implementations MUST NOT produce or consume reputation values that omit any element of this tuple.
A conforming ReputationAssertion MUST contain the following fields:
ReputationAssertion {
actor_address: string // The actor being evaluated (subject or issuer DID)
role: instructor | assessor | author | learner | mentor
skill_id: string | null // Skill scope (nullable for broad role assertions)
proficiency_level: ProficiencyLevel | null
score: number // Aggregated reputation score
evidence_count: number // Supporting evidence count
median_impact: number | null
impact_p25: number | null
impact_p75: number | null
learner_count: number | null
impact_variance: number | null
}
Assertions are stored in reputation_assertions. Each row records its computation_spec and a fingerprint of the credentials it was computed from. Readers revalidate first: a row whose inputs were revoked, altered or removed is recomputed before it is presented, and a row whose verified sample becomes empty is marked excluded rather than rewritten with a zero score.
The reference engine (evidence::reputation, computation spec v5-session-status) runs after each credential is accepted into the local store and derives two row kinds from credentials:
| Role | Scope | Inputs | Score |
|---|---|---|---|
learner |
(subject, skill, level) | Every skill-kind VC that verifies now and whose signed subject, skill and id match its row | Highest SkillClaim.score observed |
instructor |
(issuer, skill, level) | Only credentials classified as verified issuer-signed: a distinct issuer's valid signature over someone else's claim | Mean of the scores that issuer awarded |
Self-asserted, self-witnessed, and course-endorsed self-claims contribute only to the learner row. Issuer inequality alone does not credit an instructor; the signature classification does. A credential whose integrity session ended suspended or flagged enters no row when that status is reliable: the credential is issuer-signed, or its attestation evidence verified credential-bound (§14.9.5). For any other credential the status is the holder's word and is ignored.
Reputation MUST be exposed as a distribution, not as a single scalar. A conforming view MUST include median impact, 25th/75th percentile impact, variance, and learner count, computed over the sampled scores backing the row: instructor rows over the scores they issued across distinct learners, learner rows over the scores they were awarded across distinct issuers. A sample-size confidence is derived from learner_count on read.
A reputation snapshot is a self-issued DerivedCredential (§14.6.5). Its signed payload freezes every score and the contributing eligible credentials (credential ID and integrity hash). Its integrity hash MAY be anchored through the ordinary credential-anchor queue (§11.3).
Reputation is computed from the credentials in the subject's own store. Platforms that compute reputation on behalf of actors MUST NOT claim ownership of the resulting assertions.
Graded element submissions (persisted, passing)
|
v
claim_course_completion
- rebuilds gradeable evidence from persisted passing submissions
- binds the enrollment's frozen course snapshot (§5.2)
- derives the completion Merkle root
|
+--> completion_claims row + learner self-claim VCs (§14.7)
|
+--> optional completion endorsements (§5.2)
|
+--> optional completion witness: when Blockfrost is configured, a mint
under the `completion` validator is queued; the observer records
each observed mint in `completion_observations`, and auto-issuance
signs a VC whose `witness` block carries the mint tx hash and
validator script hash
|
v
Reputation recomputed for the subject (§4.5)
Assessment evidence stays on the device. What crosses the network is the signed VC, carried by the vc-did, vc-status, and vc-fetch/1.0 protocols (§6.5).
A grade from a plugin can become a credential only when the installed manifest bytes and the executed grader bytes exactly match a plugin bundled with the signed app. Any plugin may grade practice work; this restriction applies until a policy-backed community grader path exists.
Course-document format v2 can carry an author-signed completion_policy. The
policy fixes its format version, the exact authorized attestor DIDs and
Ed25519 keys, a distinct-attestor threshold, and bounded evidence
requirements. A completion endorsement signs canonical, domain-separated
bytes that bind the network, learner DID, stable course ID, exact course
document CID and format version, completion root, evidence identities and an
optional chain-witness transaction hash. The shared I/O-free verifier
(alexandria_verify::course) rejects unlisted or duplicate attestors and any
changed binding field.
New course publications emit v2 documents whose signed payload uses canonical JSON and whose author DID must match the embedded signing key. Version 1 documents remain readable and retain their original signing bytes; they cannot carry a completion policy. No policy means the completion is a learner self-claim.
Each new enrollment freezes the verified course-document CID, published course
version, and canonical completion policy on its enrollments row. Completion
claims bind that snapshot, the learner, the root, evidence, network, and exact
enrollment. Policies come only from that exact author-signed document; stored
rows never create or widen authority.
The application can export the canonical endorsement request, sign it with an
authorized local instructor key, import an endorsement only after shared
verification, and report a distinct-attestor threshold. Accepted endorsements
are stored in course_completion_endorsements, one per (claim, attestor). An
imported endorsement arrives as its exact JSON text. That text is parsed as
strict bounded JSON before verification: 128 KiB, depth 8, 64 elements, 16
entries and 1024-byte strings, with no duplicate keys, unsafe numbers or
trailing bytes. The verifier crate publishes exact-byte endorsement vectors,
which the app import and an independent verifier check. The course composer
edits the policy for the next signed publication and blocks publication while
policy changes are unsaved. The learner completion surface exports the exact
request, imports one signed artifact at a time through the verifier, and
reports the accepted threshold. The instructor surface parses the request and
displays its network, learner, course CID/version, root, evidence, and optional
witness before enabling local signing. This is an explicit manual exchange; it
does not authenticate delivery or the person presenting the request;
authenticated addressed delivery remains implementation work. Endorsements
count toward a privilege only through a qualification policy's
accepted-course-endorsement route, which requires at least
minimum_accepted_attestors endorsers from that policy's accepted issuers
(§14.14.4).
Credential status is issuer-bound. Revocation, suspension, and reinstatement require the active profile to derive the same issuer DID named by both the credential and its status-list row; no peer, committee, or DAO can change another issuer's credential status. Revocation is permanent; suspension is reversible by that issuer.
Alexandria uses libp2p 0.56 to build a decentralized P2P mesh where every user runs a local node. The protocol has 8 logical layers:
This section describes the libp2p mesh only. Content blobs and live tutoring
media travel over a second, independent stack (iroh + iroh-blobs + MoQ) with its
own relays, discovery and node identity — see
architecture.md. Claims
about relay independence in this section apply to the libp2p side; iroh currently
falls back to relays operated by a third party.
The application also embeds a strict versioned network profile at
src-tauri/resources/networks/preprod.json. It is validated before profile
state opens and centralizes the network ID, Cardano magic, relay identities and
HTTPS registry origins, receipt issuers, stake-registry founder keys, bootstrap
resource digest, and optional service identities. Each local profile is
immutably bound to that network ID. The configured protocol namespace is
/alexandria/preprod; today it namespaces DHT provider-record keys, while the
wire protocol IDs in §6.4–§6.5 remain unscoped pending a synchronized app,
relay, and monitoring migration.
| Layer | Name | Description |
|---|---|---|
| 8 | Application | Tauri IPC commands, frontend events |
| 7 | P2P Events | PeerConnected, GossipMessage, NatChanged |
| 6 | Sync | Cross-device sync (encrypted, LWW) |
| 5 | Domain | Catalog, Evidence, Taxonomy, Governance, Profiles, Classrooms |
| 4 | Validation | Signature, Identity, Freshness, Dedup, Schema, Authority |
| 3 | GossipSub | 15 global topics + per-classroom dynamic topics, peer scoring, rate limiting |
| 2 | Transport | QUIC, TCP, Kademlia, AutoNAT, Relay, DCUtR |
| 1 | Crypto | Ed25519, Blake2b-256, SHA-256 |
All messages are JSON-encoded, wrapped in a signed envelope, and published via GossipSub v1.1. Every sender is identified by their Cardano stake address and Ed25519 public key — creating a cryptographic link between P2P identity and on-chain identity.
| Function | Algorithm | Usage |
|---|---|---|
blake2b_256(data) |
Blake2b, 32-byte digest | Message dedup, entity IDs, sync keys, GossipSub message IDs |
sha256(data) |
SHA-256 | Signature pre-hashing |
entity_id(parts) |
hex(blake2b_256(parts.join("|"))) |
Deterministic IDs for courses, evidence, votes |
| Ed25519 | RFC 8032 via ed25519-dalek | All message signing |
| Transport | Address | Platform |
|---|---|---|
| QUIC v1 | /ip4/0.0.0.0/udp/0/quic-v1 |
Desktop |
| QUIC v1 (IPv6) | /ip6/::/udp/0/quic-v1 |
Desktop (best-effort) |
| TCP + Noise + Yamux | /ip4/0.0.0.0/tcp/0 |
Mobile (iOS — QUIC unavailable) |
| Relay Circuit | Full relay multiaddr + /p2p-circuit |
All (NAT traversal) |
Seven base libp2p protocols plus six request-response protocols (§6.5) compose AlexandriaBehaviour:
| Protocol | Version | Purpose |
|---|---|---|
| GossipSub v1.1 | — | Topic-based pub/sub with peer scoring |
| Kademlia | /alexandria/kad/1.0 |
Private DHT — peer discovery via relay bootstrap |
| Identify | /alexandria/id/1.0 |
Peer info exchange, push listen addr updates |
| AutoNAT | — | NAT reachability detection |
| Relay Server | — | Circuit Relay v2 server |
| Relay Client | — | Circuit Relay v2 client (NAT traversal) |
| DCUtR | — | Upgrade relayed connections via hole punching |
| Topic Path | Description |
|---|---|
/alexandria/catalog/1.0 |
Course announcements |
/alexandria/taxonomy/1.0 |
DAO-ratified skill graph updates |
/alexandria/governance/1.0 |
Governance events |
/alexandria/profiles/1.0 |
User profile updates |
/alexandria/opinions/1.0 |
Qualified field commentary and signed discussion threads/interactions |
/alexandria/peer-exchange/1.0 |
Known peer address propagation |
/alexandria/vc-did/1.0 |
DID announcements (§14.5); a did:key announcement registers nothing and only retries credentials from that issuer still pending verification |
/alexandria/vc-status/1.0 |
Bitstring Status List snapshots and deltas (§14.11.2) |
/alexandria/vc-presentation/1.0 |
Opt-in selective-disclosure presentation envelopes (§14.18) |
/alexandria/pinboard/1.0 |
PinBoard pinning-commitment observations (§14.12, §14.20.4) |
/alexandria/plugins/1.0 |
Community plugin announcements (manifest CID + metadata) |
/alexandria/plugin-attestations/1.0 |
Reserved compatibility topic. It is subscribed and scored but has no inbound persistence handler and grants no credential authority. |
/alexandria/sentinel-priors/1.0 |
Ratified Sentinel adversarial-prior metadata |
/alexandria/goal-templates/1.0 |
DAO-ratified goal → skill-graph templates (exam/curriculum/job-role) |
/alexandria/question-banks/1.0 |
DAO-ratified assessment question banks |
Until domain handlers consume verified committee outcome certificates (§10.2.1), the current implementation still subscribes to and validates the taxonomy, governance, Sentinel prior, goal-template, and question-bank topics, but its handlers reject every inbound message on them before any database read or write, so no rows, sync-log entry, or UI event result.
All 15 topics MUST be subscribed on node startup. In addition, six
request-response protocols (libp2p request-response + CBOR codec)
run alongside the gossip mesh and are 1-to-1, not gossip topics:
/alexandria/vc-fetch/1.0 handles authority-respecting credential
pull (enabled when the node has a Database wired into its swarm
event loop); /alexandria/sync/1.0 carries AES-256-GCM-sealed
cross-device sync payloads between explicitly paired devices; and
/alexandria/graph-fetch/1.0 serves a node owner's public skill
graph on demand. A graph-fetch request carries the subject_did
being asked for; a node answers Ok(PublicSkillGraph) only if it
owns that DID (matched against the device-local identity.local_did
setting), else NotOwner. The graph exposes every earned skill the
owner has marked public, flagging the subset they teach. There is no
DID→PeerId registry, so a fetch is broadcast across the requester's
connected peers and the first Ok wins; a same-DID call is served
locally (loopback). Handler + payloads: p2p::graph_fetch.
/alexandria/profile-fetch/1.0 serves a node owner's public
profile (username, display name, bio, avatar) addressable by DID or
by username. Private profiles answer Private by DID and NotOwner
by username so the username→DID binding never leaks. Handler:
p2p::profile_fetch.
/alexandria/username-reg/1.0 is client→relay only: a node submits
its signed username claim and the relay countersigns a first-seen
receipt (see docs/username-registry.md).
Username uniqueness itself rides on Kademlia records (not a
request-response protocol) under
SHA256("alexandria:username:v1:" + name), with batched Cardano
anchoring under metadata label 1698.
See §14 for the normative VC payload schemas carried by the
vc-did, vc-status, vc-presentation, and pinboard topics, and
by the vc-fetch/1.0 request-response protocol.
/alexandria/guardian/1.0 is the sixth request-response protocol and the only
cross-user one: it links a minor learner to a parent/guardian who is a
different identity on a different device. Unlike device sync — which pairs two
devices of the same user and authenticates on a matching stake address — the
guardian link is authorised purely by possession of a single-use invite code,
then by a per-link AEAD key for everything after.
Flow:
- A gated minor (
activation_state = pending_guardian) callsguardian_create_invite, producing aGuardianInvite— the same base64url shape as aPairingCode(child DID, stake, peer id, dial addresses, a fresh 32-byte shared key, display name). Itscode_hashis stored inguardian_pending_invites; the code is shown on the holding screen and is valid ~7 days (the code waits for an offline parent, not a live connection). - The parent runs
guardian_accept_invite(code), dials the child, and sendsGuardianRequest::Linkcarrying a guardianship W3C VC (issuer = parent DID, subject = child DID, Ed25519 proof) plus AEAD-sealed metadata. - The child verifies the VC, consumes the invite (single-use — replays are
rejected), stores the link + VC, issues a reciprocal ward VC, sets
activation_state = active, and repliesLinkedwith an initial sealed activity snapshot. Aguardian-link-changedTauri event live-unblocks the gate. - Ongoing oversight: the child pushes AES-256-GCM-sealed
SyncRowpayloads (GuardianRequest::ActivityPush, reusing thep2p::syncseal/LWW helpers) over an allowlist of tables (enrollments, progress, submissions, …); the guardian merges them intoguardian_activity_rowsand canActivityPullon dashboard open.
Requests: GuardianRequest::{Link, ActivityPush, ActivityPull, Revoke}.
Responses: GuardianResponse::{Linked, Merged { rows }, Sealed, Unauthorized, Error}.
The handler is the pure fn handle_guardian_request(conn, peer_id, req)
(unit-tested in tests/guardian_e2e.rs with real wallets and VC signing).
Turning 18 / revocation: is_minor is recomputed from the birthdate on every
unlock, so a ward automatically ages out and gains guardian_revoke_link (VC
status-list revocation + a Revoke message). While still a minor the ward
cannot revoke; a guardian-side revoke returns the child to the
pending_guardian gate.
Privacy invariants (test-enforced): guardianship VCs and the birthdate are
never announced on any VC gossip topic, are excluded from the public
profile-fetch / graph-fetch responses and credential-export defaults, and
travel exclusively over this sealed protocol. guardian_links and
guardian_activity_rows are not in the device-sync SYNCABLE_TABLES.
Handler + payloads: p2p::guardian; commands: commands::guardian.
The discussion_version: 1 payload is carried inside the signed gossip
envelope (§6.6). Its network-bound JCS payload has its own Ed25519 author signature,
allowing another peer to relay the original event in a fresh outer envelope.
Post/comment creation IDs bind author, network, topic, parent, nonce, timestamp,
and content. Actions include post, comment, edit_post, edit_comment, delete,
vote (-1/0/1), and report. The inner signature must resolve to actor_did.
Creation and editing require topic-qualified, actor-subject credentials. Portable signed credential bytes and optional course policy/binding/endorsement evidence travel with the event and are independently verified by each receiving node. Missing dependencies remain invisible in a bounded pending queue. Votes use one row per item and DID, ordered by revision then event hash; identities are not proof of unique people. Edits are author-only; deletion is an absorbing tombstone and does not erase retained event history or other peers' copies. Reports are signed public signals, not automatic moderation decisions.
The active profile relays batches of retained accepted events every 30 seconds.
This provides eventual replay from connected retaining peers, not guaranteed
centralized storage. Field-commentary OpinionPayload messages on the same
topic (payloads without discussion_version) take a separate handler that
requires a credential satisfying a pinned subject qualification policy (§14.14.4).
Every message on the network MUST be wrapped in a SignedGossipMessage:
{
"topic": "/alexandria/catalog/1.0",
"payload": "<bytes>",
"signature": "<bytes:64>",
"public_key": "<bytes:32>",
"stake_address": "stake_test1u...",
"timestamp": 1740000000
}| Field | Type | Size | Description |
|---|---|---|---|
topic |
String | variable | GossipSub topic this was published on |
payload |
Vec<u8> |
variable | JSON-encoded, topic-specific data |
signature |
Vec<u8> |
64 bytes | Ed25519 signature over canonical bytes |
public_key |
Vec<u8> |
32 bytes | Sender's Cardano payment verification key |
stake_address |
String | ~60 chars | Sender's Cardano stake address (bech32) |
timestamp |
u64 | 8 bytes | Unix timestamp (seconds) of message creation |
The signature MUST cover ALL envelope fields: SHA-256(topic || timestamp_be_bytes || stake_address || payload). The public_key is the Cardano payment verification key, NOT the libp2p peer key — this links messages to on-chain identity.
Every incoming gossip message MUST pass through a 6-step validation pipeline. A per-peer token-bucket rate limiter (20 msgs/60s) is applied before the pipeline.
| Step | Check | Rejection Error |
|---|---|---|
| 1. Signature | Ed25519 verify over canonical bytes | InvalidSignature |
| 2. Identity | For privileged topics (taxonomy, governance, Sentinel priors, goal templates, question banks, and the reserved plugin-attestation compatibility topic), (stake_address, public_key) MUST appear in stake_pubkey_registry within the current validity window. Non-privileged topics skip. This check does not grant domain authority to the reserved topic. See docs/stake-pubkey-registry.md. |
IdentityMismatch |
| 3. Freshness | Timestamp within ±5 minutes of local clock | ExpiredMessage |
| 4. Dedup | Blake2b-256 hash not in LRU cache (100,000 entries) | DuplicateMessage |
| 5. Schema | Payload is strict JSON within the payload limits (64 KiB, depth 32, 4096 elements, 256 entries, 64 KiB strings) with no duplicate keys, integers outside ±(2^53−1), non-finite numbers or trailing bytes; topic handlers then decode the expected type | InvalidSchema |
| 6. Authority | Topic-specific permission checks; release builds reject taxonomy, governance, goal-template and question-bank messages outright (§6.5) | Unauthorized |
Before step 1, the envelope MUST decode as strict JSON within 64 KiB, depth 2, 65,536 array elements (the byte arrays), 16 entries and 1024-byte strings; otherwise it is a protocol violation. Unsigned peer exchange announcements are limited to depth 2, 64 addresses, 8 entries and 1024-byte strings.
The first failing step rejects the message. Validation outcomes MUST feed gossipsub peer scoring via report_message_validation_result — Reject on protocol-violation failures (signature, envelope parse, identity binding), Ignore on rate-limit drops, Accept on success — so the source's per-topic invalid_message_deliveries score moves correctly.
| Parameter | Value | Purpose |
|---|---|---|
| Topic score cap | 100.0 | Max positive topic contribution |
| IP colocation weight | -10.0 | Anti-Sybil (same IP penalty) |
| IP colocation threshold | 3.0 | Peers on same IP before penalty |
| Behaviour penalty weight | -10.0 | Protocol misbehaviour |
| Decay interval | 1 second | Score decay tick |
| Retain score | 3,600 seconds | Remember scores after disconnect |
| Threshold | Value | Effect |
|---|---|---|
| Gossip | -10.0 | Suppress gossip control messages |
| Publish | -50.0 | Suppress publishing to peer |
| Graylist | -80.0 | Drop all messages from peer |
| Accept PX | 5.0 | Trust for peer exchange |
| Opportunistic graft | 3.0 | Trigger grafting above median |
Fourteen of the fifteen signed topics carry per-topic scoring parameters; peer-exchange traffic intentionally bypasses scoring because its payload is unsigned. The privileged-tier topics (taxonomy, governance, Sentinel priors, the reserved plugin-attestation channel, goal templates, question banks) share the strongest invalid_message_deliveries_weight = -50.0. Plugin-attestation messages receive transport validation and scoring for compatibility, but the domain layer ignores them and they cannot authorize grading or issuance.
| Topic | Weight | First Delivery | Invalid Penalty | Invalid Decay |
|---|---|---|---|---|
| Taxonomy | 1.0 | 5.0 | -50.0 | 0.3 |
| Goal Templates / Question Banks | 1.0 | 5.0 | -50.0 | 0.3 |
| Sentinel Priors | 1.0 | 4.0 | -50.0 | 0.3 |
| Plugin Attestations | 1.0 | 3.0 | -50.0 | 0.3 |
| Governance | 0.8 | 3.0 | -30.0 | 0.3 |
| VC layer (vc-did, vc-status, vc-presentation, pinboard) | 0.6 | 2.0 | -15.0 | 0.5 |
| Plugins | 0.4 | 1.5 | -15.0 | 0.5 |
| Catalog | 0.5 | 2.0 | -10.0 | 0.5 |
| Opinions | 0.4 | 1.5 | -20.0 | 0.5 |
| Profiles | 0.3 | 1.0 | -5.0 | 0.5 |
| Peer Exchange | (no scoring profile — unsigned envelopes) |
Taxonomy and the active privileged-tier topics share the strongest invalid-message penalty because unauthorized publications on them can corrupt global state. The reserved plugin-attestation topic retains the same score profile until its coordinated protocol retirement. Authoritative values live in src-tauri/src/p2p/scoring.rs.
When behind NAT: (1) Circuit Relay v2 via relay peers — obtain /p2p/<relay>/p2p-circuit addresses, (2) DCUtR hole punching to upgrade relayed connections to direct. AutoNAT probes determine reachability with retry interval of 60 seconds and confidence max of 2.
The relay server serves as the bootstrap node and has no special protocol authority. It provides initial contact for Kademlia DHT bootstrapping and Circuit Relay v2.
Sync messages are encrypted with a key derived from the wallet signing key (AES-256-GCM). Only devices with the same BIP-39 mnemonic can decrypt sync data.
| Table | Merge Strategy | Description |
|---|---|---|
enrollments |
LWW | Course enrollment status |
element_progress |
LWW | Learning progress per element |
course_notes |
LWW | User's course notes |
SYNCABLE_TABLES (domain/sync.rs) currently holds exactly these three tables, all Last-Writer-Wins. No append-only table ships.
LWW (Last-Writer-Wins): Compare updated_at timestamps (ISO 8601 string comparison). Remote wins only if remote.updated_at > local.updated_at (strictly newer). Ties: local wins.
Append-Only Union: Insert if primary key does not exist. Never update or delete existing records. The merge helper is implemented but unused: no table in SYNCABLE_TABLES uses this strategy.
Four message types: Hello (handshake with platform and sync vector), RequestSync (request rows newer than timestamps), SyncData (response with rows and operations), SyncAck (acknowledgement with merge counts).
Table names are validated against an allowlist before use in dynamic SQL queries. Any table name not in SYNCABLE_TABLES is rejected.
Skills are organised in a three-tier hierarchy: Subject Fields → Subjects → Skills. Skills form a directed acyclic graph (DAG) with explicit prerequisite edges stored in skill_prerequisites (composite PK: skill_id, prerequisite_id). Non-prerequisite relationships (e.g., "related to", "builds on") are stored in skill_relations.
The DAG MUST be validated for cycles before inserting any prerequisite edge.
Skills carry references to external taxonomies (ESCO, O*NET) to support interoperability.
Taxonomy updates are committee-gated via the governance system and propagated over the /alexandria/taxonomy/1.0 GossipSub topic. All taxonomy changes are versioned (taxonomy_versions), and existing credentials remain valid across taxonomy versions. Backward-compatible parsing is required. The implementation has no local ratification path: the bundled public taxonomy is authoritative, and inbound taxonomy gossip is rejected before any database access (§6.5).
Two further content types are DAO-ratified through the same committee-gated, versioned, gossip-propagated flow as taxonomy:
- Goal templates — exam / curriculum / job-role → ideal-skill-graph maps (
goal_templates, versioned ingoal_template_versions), propagated on/alexandria/goal-templates/1.0under thegoal_template_changegovernance category. - Question banks — assessment question banks (
question_banks, whose items live inassessment_items), propagated on/alexandria/question-banks/1.0under thequestion_bank_changecategory. Answer keys and hidden test cases (assessment_items.grader_private) are held locally and never published in the ratified document or sent to a client.
Both follow propose → signed-vote → resolve → publish (content CID) → peers fetch + apply, mirroring taxonomy ratification. Bundled templates and banks ship with the app, labelled taxonomy_version = 'bundled', so day-one offline use works.
Implementation status: there are no content proposal, ratification or apply commands, and inbound goal-template and question-bank version documents are rejected before any database access (§6.5). Bundled templates and banks are authoritative.
Consumers MUST: query by skill (not by identity), use thresholds (not rankings), and respect selective disclosure.
Consumers MUST NOT construct queries that rank individuals globally or that bypass learner disclosure preferences.
SkillQuery {
skill_id: string
minimum_proficiency: ProficiencyLevel
minimum_confidence?: number
}
The minimum_confidence field is OPTIONAL. When omitted, implementations SHOULD apply a platform-defined default threshold.
CompositeSkillQuery {
required: SkillQuery[]
optional?: SkillQuery[]
}
A result MUST satisfy all entries in required. Entries in optional are RECOMMENDED for ranking but MUST NOT be used as exclusion criteria.
ReputationConstraint {
role: instructor | assessor | author
skill_id: string
proficiency_level: ProficiencyLevel
minimum_median_impact?: number
}
A conforming QueryResult MUST include: subject_id, matched_skills, and explanation. The explanation field MUST provide a human-readable justification for the match. Implementations MUST NOT return opaque or unexplained scores.
The following patterns are explicitly non-conforming: global rankings of individuals, hidden or opaque scoring mechanisms, and resume-style keyword inference in lieu of verified credentials.
Governance in Alexandria MUST be fully decentralised, meritocratic, and evidence-based. Decision-making authority SHALL derive from demonstrated expertise as measured by scoped reputation. Governance MUST NOT derive authority from seniority, wealth, or title.
The governance hierarchy mirrors the platform's knowledge taxonomy. When a new Subject Field is created, the system MUST automatically instantiate a corresponding top-level DAO. Each Subject within a Subject Field MUST automatically receive its own Sub-DAO.
An active DAO MUST begin from a public, one-time founding-genesis document accepted by exactly seven independently controlled founding members. Its canonical core MUST contain the human-readable name and scope, protocol and rules versions, all seven member identifiers and their distinct identity, consensus, and governance public keys, five-of-seven receipt and outcome thresholds, the two-thirds proposal-approval fraction, a positive minimum eligible-voter turnout count, the initial qualification policy, and CometBFT activation parameters. The core MUST NOT contain a DAO ID or genesis hash.
Each listed founder MUST prove control of all three declared keys by signing the same domain-separated, JCS-canonical core bytes. Each member identifier MUST equal the did:key derived from that member's identity public key. Member identifiers, members, acceptances, issuer identifiers, and assessment-evidence identifiers MUST use their specified canonical ordering, and key material and signatures MUST use canonical lowercase encodings. A conforming verifier MUST reject missing, duplicate, reordered, reused, malformed, or invalid members, keys, and acceptances. Five operational signatures are insufficient to create a founding roster: all seven founding acceptances are required.
Every accepted value MUST have one reviewable spelling. The display name MUST be at most 256 UTF-8 bytes with no leading or trailing space, and MUST NOT contain control or format characters (including bidirectional overrides and zero-width characters), other invisible default-ignorable characters, private-use or noncharacter code points, or any whitespace other than an inner U+0020 space. Scope, version, assessment-evidence, and member identifiers MUST be non-empty printable ASCII without spaces, at most 128 bytes; accepted issuer identifiers follow the same rule with a 256-byte limit; and each qualification-policy list MUST contain at most 64 entries. The CometBFT chain ID MUST be at most 50 bytes of lowercase ASCII letters, digits, -, _, and ., beginning and ending with a letter or digit. Because JCS encodes numbers as IEEE-754 doubles, integers whose magnitude exceeds 2^53−1 MUST be rejected.
The genesis hash and DAO ID MUST both be the lowercase hex BLAKE2b-256 digest of "alexandria/governance/genesis-core-id/v1" || 0x00 || JCS(core). Acceptances are excluded from this digest: Ed25519 signatures over identical bytes can differ, so re-signing an unchanged core MUST NOT produce a second DAO ID. The ID identifies a DAO only after the verifier has verified the complete canonical envelope, including all seven acceptances and their 21 key-control signatures; a claimed ID that does not match the core MUST be rejected. The canonical JSON envelope is the authoritative genesis artifact and MUST NOT exceed 256 KiB. Different cores, including cores with the same display name or scope, derive different DAO identities.
A client MUST explicitly pin the exact verified canonical envelope before treating the DAO or any descendant committee certificate as trusted. Discovery, sync, an application default or update, and optional Cardano anchoring MUST NOT automatically create, replace, or reset that local trust anchor. Pinning identical bytes again is idempotent. A different valid envelope over an already pinned core MUST NOT replace the stored bytes; the implementation accepts it without storing it and reports newly_pinned: false with stored_envelope_differs: true. Any other envelope under a pinned DAO ID MUST be rejected. An epoch of committee authority is obtainable only from a verified genesis, not from separately stored or deserialized epoch data.
A portable genesis locator is discovery metadata, not authority. It MUST NOT embed the founding-genesis envelope or cause automatic retrieval or pinning. Its encoded form MUST NOT exceed 2 KiB and MUST contain only:
- the genesis-derived, lowercase 64-hex DAO ID;
- the lowercase 64-hex BLAKE3 hash of the authoritative canonical JSON bytes; and
- between two and eight content-addressed retrieval locations, each on a distinct origin.
The accepted top-level forms are alexandria://governance/genesis/<dao-id> and https://alexandria.ifftu.dev/governance/genesis/<dao-id>. They carry one content=<BLAKE3> field and repeated source=<location> fields. Unknown or duplicate singleton fields, credentials, ports, fragments, whitespace, and non-canonical paths MUST be rejected. A source MUST be either the exact identifier iroh://<BLAKE3> or an HTTPS URL with the same expected digest in an unsent #blake3=<BLAKE3> fragment. An HTTPS source MUST use the https scheme on its default port and MUST NOT contain userinfo, an IP-literal host, a trailing-dot host, or a single-label or special-use/private-use name (such as localhost, .local, .internal, .home.arpa, .onion, .test, or .example). Sources are normalized (including host case, the default port, and RFC 3986 percent-encoding of the path and query) and counted by origin: the iroh network, or one HTTPS host. Two sources on the same origin, including different paths or spellings of one host, MUST be rejected, so one party cannot satisfy the two-source minimum alone.
Opening a locator MAY parse, normalize, and display these identifiers, but MUST perform no network access and MUST NOT mutate content or governance trust state. Retrieval requires a separate explicit user action and MUST fetch only the normalized sources of the reviewed locator: a client MUST NOT follow HTTP redirects or fall back to any other location recorded for the same content hash. The retrieved bytes MUST match the declared BLAKE3 digest, satisfy the founding-genesis size and canonicalization rules, verify every founding acceptance, and derive the locator's declared DAO ID. A client MUST then show the complete material trust facts, including all founder identifiers and keys, rules, thresholds, qualification policy, scope, activation data, the full DAO ID and equal core hash, and the BLAKE3 hash of the exact envelope bytes. Pinning requires a third explicit user action confirming the complete DAO ID and MUST persist the exact reviewed canonical bytes. QR codes encode only the normalized locator. Source concurrency, racing, and timeout budgets are implementation policy and remain subject to the performance profile; they do not weaken any verification or consent requirement. The implementation performs no blocking DNS lookup inside those budgets: reviewed hosts are checked without DNS, and its HTTP client's connect-time resolver rejects non-public addresses.
Top-level DAO elections MUST be held every four (4) years for all seats on the governing committee. Sub-DAO elections MUST be held annually for all roles.
Nominations for all DAO committee elections MUST be automatic and reputation-based. Each nominee MUST disclose their full reputation proof history to the DAO membership prior to the election. Nominees MUST explicitly accept or decline through active consent. The system MUST NOT enroll any actor as a candidate without their recorded consent.
Each DAO MUST accept proposals from its members. The proposal lifecycle proceeds through: Draft Stage (any member may submit; draft specifies minimum skill level to vote), Committee Review (committee must approve advancement to published state), Published Stage (all qualified members may cast a vote; skill-level gate enforced at vote time).
DAO membership is any actor who holds the relevant skill levels within the scope of that DAO. Membership MUST be computed dynamically from current credentials and MUST NOT be granted through manual assignment.
To participate in governance (open an election, nominate, accept a nomination, start/finalize voting, submit/approve/vote on proposals), an actor's stake address MUST be bound to its signing public key in the persistent stake_pubkey_registry. Peers verify this binding before accepting a gossiped governance action, and the local node refuses to produce one without it. The binding is established by a signed on-chain stake_pubkey_registration or a multisig-signed bootstrap snapshot.
The lifecycle above describes the target governance rules. The application has no local DAO, election, nomination, committee, or proposal actions and submits no governance transactions; inbound /alexandria/governance/1.0 events are rejected before any database access until verified committee certificates exist (§6.5). The DAO validators in cardano/governance/validators/ (dao_registry, dao_minting, election, proposal, vote_minting) are deployed as preprod reference scripts but are not an authority path.
The Alexandria specification SHOULD be governed by a neutral, public-interest body. The governing body MUST adhere to the following principles: open participation, transparent decision-making, and no proprietary extensions to core schemas.
All changes to this specification MUST be versioned. Breaking changes MUST require a major version increment. Existing credentials and ReputationAssertions MUST remain valid across version boundaries.
Implementations MUST: support backward-compatible parsing of all prior schema versions, ignore unknown fields safely, and fail explicitly on incompatible versions.
Alexandria MUST avoid dependence on any single provider for content storage, credential verification, or identity management. Decentralisation applies across three domains: content distribution, credential anchoring, and identity.
All learning content MUST be stored in the iroh content-addressed blob store and addressed by BLAKE3 hash. Published course content MAY also be available via public URLs with local BLAKE3 caching. Content is propagated across the P2P network via the catalog GossipSub topic.
Once published, content hashes are immutable. Content updates produce a new hash and a new version record.
Blockchain: Cardano (Conway era) via pallas 0.35 and Blockfrost.
Credential integrity is anchored via the W3C-VC integrity-anchoring path (§11.3.1), which timestamps a verifiable hash of the canonical VC without publishing credential content. A credential is never itself a token (the completion witness in §5.1 is a separate mint). Reputation snapshots (§4.7) are DerivedCredential VCs and use the same anchor.
The §14 Verifiable Credentials path anchors credential integrity on Cardano in batches. An issuer's node collects the integrity hashes H(c) of the credentials it issued, builds a Merkle tree over them (§14.12.3), and records the root in one transaction under metadata label 1697 (ALEXANDRIA_ANCHOR_LABEL), version 2:
{ 1697: { "root": <hex>, "leaf_count": <n>, "issuer_did": <did:key:z…>,
"anchored_from": <ISO 8601>, "v": 2 } }
anchored_from is the earliest issuance time in the batch. H(c) is blake3 of the JCS-canonical bytes of the VC with proofValue emptied (§14.23.2). The full credential is NOT stored on-chain. Anchoring is an integrity-timestamping mechanism; it neither creates nor transfers a token and does not replace the signature-based verification defined in §14.13. Version-1 records (one hash per transaction) are no longer written or read.
The key of the issuer's did:key MUST be a required signer of the anchor transaction, however it is funded, so the anchor is attributable to the DID itself. Only the issuer's own node anchors; a credential received from elsewhere is never anchored by its holder. A node flushes a batch once its oldest queued credential was issued six hours ago, or once 256 are queued. A batch is bound to its exact signed bytes before it is sent and is never rebuilt. It is replaced by a new batch only when it failed on chain or can no longer be included (the tip has passed its validity interval by a margin).
Each credential in a confirmed batch gets an anchor receipt (§14.12.3), kept beside the credential and exported in credential bundles (§20.4). A holder's node keeps the receipts that arrive with a bundle and looks their transactions up on the ledger.
Funding. The fee is paid by the anchor sponsor when the network profile names one, and by the issuer's wallet otherwise. The sponsor is a Plutus V3 spending validator (anchor_sponsor) holding the Alexandria treasury's anchoring funds, split across many UTxOs, so no node needs a treasury key. It is parameterised by a fee cap, a rate-limit window, a maximum validity-interval width (smaller than the window) and an m-of-n reclaim multisig. Its inline datum is next_allowed (POSIX ms). Its Sponsor redeemer passes only when:
- exactly one input is the script's and exactly one output returns to the script's address;
- the lovelace leaving the script is at most the fee cap and at most the transaction's fee, so it can pay the fee and nothing else, and the output keeps the input's native assets;
- the validity interval is finite, no wider than the maximum width, and starts at or after
next_allowed; - the output datum's
next_allowedis the interval's lower bound plus the window; - at least one key signed.
The validator never reads the anchor record: Plutus scripts cannot see metadata, and sponsored and self-funded anchors verify the same way. A spender gains nothing from the fee, so the worst a malicious node can do is spend fee cap × pool UTxOs per window. Reclaim passes with m-of-n reclaim signatures and recovers or moves the funds. A sponsored spend needs collateral from the issuer's own wallet, which the ledger takes only if the script fails. The sponsor's script hash, address, reference-script UTxO, parameters and the network's slot-to-POSIX offset are read from the network profile (anchor_sponsor); until it is deployed there, issuers fund their own anchors. A batch that cannot be built or paid for stays queued with the reason; only a batch that failed on chain or expired counts toward a credential's attempts.
The user's 24-word BIP-39 mnemonic IS their identity. Key derivation follows CIP-1852 via pallas-wallet, producing a payment key (m/1852'/1815'/0'/0/0) and a stake key (m/1852'/1815'/0'/2/0). The payment key serves as the Cardano signing key, the message signing key for gossip envelopes, and the DID-key signing material for the VC layer (§14.5). The libp2p peer identity is derived per device by HKDF over the payment key plus a device-local secret (device_id), so the same mnemonic loaded onto two devices yields distinct PeerIds. The stake key signs stake_pubkey_registration transactions that bind the stake address to the gossip-envelope public key for privileged-topic authority (see docs/stake-pubkey-registry.md). There is no email, no OAuth, and no custodial wallet service.
Learners MUST retain full control over which credentials and reputation data are disclosed to third parties. No query result SHALL include data from credentials or proofs that the learner has not explicitly chosen to disclose.
Sentinel is a client-side anti-cheat system that monitors assessment integrity through multi-signal behavioral fingerprinting. All processing happens on-device. Raw behavioral data MUST NOT leave the client.
- Privacy-first — All behavioral data (keystrokes, mouse movements, video frames) is processed entirely on-device. Only numeric scores and categorical flags are stored and broadcast.
- Non-punitive by default — Sentinel informs rather than punishes. A single flag sends a session to review; a credential-affecting outcome needs two independent channels over a certified threshold or a failed verification step. Only backend-recorded assistant use suspends.
- Measured before it counts — Every signal is advisory until a reviewed certification admits it with an error rate measured on a labelled corpus. No certification is in force yet.
- On-device, no downloads — All ML models run on-device with no model downloads or remote inference. The keystroke autoencoder and mouse-trajectory CNN run in Rust on the
candleframework; the face embedder is hand-written TypeScript (LBP histograms). The paste classifier runs viatract(pure Rust ONNX); its weights are embedded withinclude_bytes!, and no command replaces them at runtime. - Incremental trust — Behavioral profiles build over time. Consistency scoring activates after 10+ samples.
| Signal | Source | Type | Weight |
|---|---|---|---|
typing_consistency |
Rule | 0-1 | 0.20 |
mouse_consistency |
Rule | 0-1 | 0.15 |
is_human_likely |
Rule | bool | 0.15 |
tab_switches |
Rule | count | 0.15 |
paste_events / pasted_chars |
Rule | count | 0.10 |
face_present / face_count |
Rule | bool/int | 0.15 (camera opted in) |
ai_keystroke_anomaly |
AI | 0-1 | advisory |
ai_mouse_human_prob |
AI | 0-1 | advisory |
ai_face_similarity |
AI | 0-1 | advisory |
ai_paste_anomaly |
AI | 0-1 | advisory |
gaze_offscreen_ratio |
AI | 0-1 | advisory |
liveness_real_prob / liveness_checks / liveness_spoof_checks |
AI | 0-1 / int | advisory |
app_switch |
Native | event | advisory |
display_count / external_display / split_screen / screen_captured |
Native | int / bool | advisory |
foreign_accessibility_services / adb_enabled / obscured_touches |
Native (Android) | int / bool | advisory |
hidden_overlays / overlay_windows_scanned |
Native (desktop) | int | advisory |
watched_processes / watched_categories |
Native (desktop) | int / list | advisory |
global_hotkeys / phantom_hotkeys |
Native (desktop) | int | advisory |
camera_device_virtual |
Rule | bool | advisory |
The client submits raw per-window features; the issuing device derives every score and flag from them, and a snapshot carrying any client-computed score or flag (including the retired devtools_score) is rejected. The weights build a descriptive composite score: relative coefficients divided by the coefficients actually present, so a missing optional signal contributes neither score nor denominator. The composite no longer decides a session's outcome. Response-process signals (time to first input against a reading floor, uniform relay lag, idle-then-burst, answer change after idle, gaze-down or second voice just before a response) and longitudinal divergence at grading are further advisory signals. Each signal's thresholds, the flag it raises, and that flag's severity are specified in docs/sentinel.md (Signal Taxonomy, Flagging Logic); flag severity is authoritative on the issuing device, and an unknown flag counts as info.
Three per-user models are trained on-device. The keystroke autoencoder and mouse-trajectory CNN run in Rust on the candle ML framework (src-tauri/src/sentinel/keystroke_ae.rs, mouse_cnn.rs); the face embedder is hand-written TypeScript. Frozen models (paste classifier, YuNet face detector, MiniFASNetV2 liveness) are embedded ONNX run by tract, each pinned by a SHA-256 lockfile; the gaze calibration MLP is per-user candle:
- Keystroke Autoencoder (4→8→4→8→4) — Digraph timing features, anomaly detection via reconstruction error. Requires 20+ samples. Threshold: 0.65.
- Mouse Trajectory CNN (Conv1D(3→8)→Conv1D(8→16)→Dense→Sigmoid) — 50-point segments with dx/dy/dt channels. Human threshold: 0.50. Conv layers use reservoir computing (random feature extractors).
- Face Embedder (LBP histograms, 4×4 spatial binning, 944-dimensional) — Cosine similarity for continuous identity verification. Match threshold: 0.70. Uses YCbCr skin-color segmentation.
Signals are grouped into independent evidence channels. Each window a signal fires adds its certified log-likelihood ratio to its channel; a signal without a certified ratio adds zero and is advisory. A session's status follows, in order:
- Suspended: assistant use recorded by the backend during an attempt (
in_app_assistant_during_attempt,mcp_call_during_attempt). An interview-purpose session isflaggedinstead. - Flagged: a failed verification step, or two channels over the trust profile's threshold.
- Review: any warning or critical flag, or one channel over threshold.
- Completed: anything else, once the session ends.
Status only moves up. Flag severity is authoritative on the issuing device, and an unknown flag counts as info in a channel of its own.
At session start the issuing device locks the session to one trust profile: core, attested (core + device attestation), camera (core + camera) or full (core + both), the highest the device's attestation, capabilities, a camera benchmark, per-capability consent and the sponsor's policy floor permit. The selection is the first link of the session's commitment chain. A signal lost afterwards is recorded as degraded, never renegotiated, and a signal the profile does not include is recorded as not run.
The verification rung records positive evidence independent of the device, as a strict ladder: none → process (response-process signals observed over every served item, from the backend's draw) → probed (every follow-up probe on the learner's own answers satisfied, at least one of them asking a question the learner had not already answered) → consistent (the outcome agrees with the learner's own history on the skill) → live (a live segment in an interview held in Alexandria). Missing or skipped evidence leaves a session a rung lower and never counts against the learner; a failed probe flags the session.
Probe rules. A same-item probe (reseed: the item again with a new seed) still runs, and a failed one still flags the session, but it never earns probed: only an authored follow-up or variant, a plugin's own probe or a generated probe does. A probe's time limit is fixed by the item, never by the attempt's pace: the limit its author set, or else the response-process reading floor over its prompt and option text at its difficulty, times 4, plus 20 seconds, clamped to 15 seconds–5 minutes. Plugin probes keep the grader's time box; a generated probe gets the reading-floor default from its own text and the item's difficulty. In a hosted attempt (§14.9.7) a probe is another item on the same skill the candidate was never sent, drawn, timed and graded by the issuer; one answered after its limit fails.
A session reaches the credential through the integrity attestation block (§14.9.5), with the terminal status, the composite score, the profile, the rung and the coverage statement digest. Coverage statements and the measurement behind certified rates are specified in docs/sentinel.md (Trust profiles, Verification rungs, Integrity Assurance).
These guarantees are architectural — they are enforced by the code structure, not by policy.
- Raw keystrokes never stored: Only anonymized timing features (dwell/flight in ms).
- Raw mouse coordinates never transmitted: Only deltas used for CNN features.
- Video frames leave the device only on a learner-initiated appeal: face processing happens on a canvas element and frames are never written to disk by default. A flagged session's frames may be retained on-device for 14 days at the learner's explicit choice, and released by them to contest the flag — see
sentinel.md§Review and adjudication. - AI model weights are not biometric data: Weights encode statistical patterns, not recoverable input data.
- Profile keyed to device: Profiles are device-specific.
- No server-side data: All behavioral processing happens on-device.
- Native environment checks return matches, not inventories: process and window enumerations stay in the backend (only watchlist matches and suspicious windows' owner and reason cross IPC, never titles); the shortcut monitor records only modifier combos and refuses text-entry chords; a camera's device label is never persisted.
- Device attestation carries no identity: the platform key is per-app, per-install, and the stored blobs bind a nonce and an app id, not a person.
- Consent is per capability: camera, microphone and companion phone are separate choices recorded on the session; none is enabled because the device has it.
- Voice checks in interviews are never recorded, transcribed or stored: only voice onset times and whether a second voice was present are used.
- Under a sponsor's
llmprobe policy, the skill and the text of the learner's chosen options leave the device for the sponsor's model connection, only with the learner's consent at attempt start; the item's prompt, other options and key never do. - Monitoring cannot see a second person or a second device, and every coverage statement says so.
Threat: Actors attempt to inflate reputation via low-signal instruction, collusion, or selective assessment.
Mitigations: Reputation inputs are credentials that verify now, are not revoked, and whose signed subject, skill and id match their row; stored rows are recomputed when those inputs change. Signature validity alone grants no privilege. Reputation remains skill- and proficiency-scoped, with distribution statistics, provenance/type weights, and independence penalties.
Threat: Instructors or assessors inflate scores to boost downstream reputation.
Mitigations: Assessment definitions are independent of the instructor. Difficulty and assessment type weighting, Sentinel integrity state, variance, confidence penalties, exact bundled-grader byte binding, and issuer policy determine whether an outcome contributes trust or a privilege. Proficiency-derived privileges additionally require an accepted issuer under a pinned subject qualification policy (§14.14.4).
Threat: Creation of multiple fake identities to manipulate attribution or governance.
Mitigations: Instructor reputation grows only from verified issuer-signed credentials over other subjects' claims (§4.5); self-issued and self-witnessed claims credit no instructor. IP colocation scoring in P2P layer (-10.0 weight above 3 peers threshold). Optional identity verification layers. Graph-based anomaly detection supported by data model.
Threat: Forged or tampered gossip messages.
Mitigations: Ed25519 signatures on all gossip messages, covering all envelope fields (topic, timestamp, stake_address, payload). 6-step validation pipeline with per-peer rate limiting.
Threat: Unauthorized modification of the global skill graph.
Mitigations: Highest topic weight (1.0) and strongest invalid penalty (-50.0) in peer scoring. Privileged-topic identity binding at the validation layer (§6.7). Until handlers consume verified committee outcome certificates, every inbound taxonomy, governance, goal-template, and question-bank message is rejected before any database access (§6.5), so no single signer and no gossiped committee event can change local state.
Threat: Modification of course content or credential metadata.
Mitigations: BLAKE3 content addressing (iroh). Ed25519 signed documents. Published content hashes are immutable.
Threat: Re-broadcasting valid but expired messages.
Mitigations: ±5 minute freshness window. Blake2b-256 dedup cache (100,000 entries, LRU eviction).
Threat: Someone else taking assessments on behalf of the learner, or use of automated tools.
Mitigations: Sentinel behavioral fingerprinting (keystroke, mouse, face). Client-side ML models for continuous identity verification. Native environment signals (displays, overlays, watched processes, hotkeys). Integrity-gated issuance (§14.9.5) carries the session outcome inside the signed credential.
Threat: Compromise of wallet keys or mnemonic.
Mitigations: Per-profile encrypted vault — Stronghold (desktop) or AES-256-GCM + Argon2id (mobile), one vault per profile. 12-character minimum password. Salt file HMAC-SHA256 integrity protection. Wallet struct implements Drop with zeroization; Clone removed. Biometric session password auto-clears after 15 minutes. A stolen device exposes only the data of profiles whose passwords are also compromised; other profiles on the same device remain encrypted.
Threat: Theft of an issuer's signing key enables the attacker to mint arbitrary VCs in the issuer's name.
Mitigations: A did:key cannot rotate (§14.5.3). A learner whose key is compromised starts a new identity; identity recovery is unspecified. An organisation removes the compromised key from its domain descriptor, which withdraws organisation backing from every credential that key signed while their signatures still verify. The compromised issuer SHOULD revoke affected credentials via the §14.11.2 status list while it still controls the key. §14.14.4 permits verifiers to downgrade the issuer weight for an issuer with a history of compromise or bad-faith revocation.
Threat: An adversarial or compromised issuer flips valid credentials to revoked in the status list, de-platforming legitimate subjects.
Mitigations: Status lists MUST be issuer-signed and version-pinned (§14.11.2), so a reader can detect forgery and rollback. Subjects MAY retain pre-revocation evidence of good standing by caching signed status-list snapshots locally. Verifiers MAY downgrade issuer trust weight (§14.14.4) when observing statistically anomalous revocation rates from a given issuer.
Threat: An adversarial issuer floods the network with self-attestations, duplicate credentials, or inflated assessment scores to game the §14.14 trust score.
Mitigations: §14.15 anti-gaming controls — cluster-based Sybil cap (§14.15.1), self-attestation type-weight floor (§14.15.2), inflation z-score penalty (§14.15.3), and re-issuance spam discount (§14.15.4) — combine to bound the influence of any single issuer cluster and to discount correlated or inflated evidence.
This section defines the credentialing, attestation, verification, revocation, aggregation, and survivability model for Alexandria. It is normative.
The protocol is designed to satisfy the following properties:
- Credentials MUST remain verifiable without Alexandria-controlled infrastructure.
- Credentials MUST be non-transferable at the semantic layer.
- Each credential MUST have exactly one primary issuer.
- Multiple issuers MAY independently attest to the same skill, competency, or achievement.
- System-level trust MUST be computed through aggregation, not assumed from any single credential.
- The protocol MUST degrade gracefully if Alexandria ceases to exist.
- The protocol SHOULD support privacy-preserving disclosure and future zero-knowledge extensions.
Primary credentials MUST NOT be modeled as freely transferable NFTs because transferability destroys the semantic meaning of educational attainment.
Let C be a credential and O(C, t) be the owner of C at time t. For an educational credential to be meaningful, the following invariant is required:
∀t: O(C, t) = S
where S is the credential subject. If transfer is allowed, then there exist times t_1, t_2 such that O(C, t_1) ≠ O(C, t_2). This violates identity-binding and invalidates the credential as proof of personal achievement.
Therefore, transferable NFTs MUST NOT be the source of truth for educational or skill credentials.
Pure soulbound-token systems are directionally useful but insufficient as a complete architecture because they typically fail one or more of: revocation flexibility, correction workflows, selective disclosure, portability across wallets and DID methods, and long-term resilience across infrastructure changes.
A credentialing protocol for Alexandria MUST support: issuance, verification, expiration, revocation, selective presentation, organisation key replacement (§14.5.3), and issuer continuity (or graceful issuer death).
Therefore, Alexandria adopts a VC-first architecture, optionally with SBT-like semantics at the presentation layer, but NOT as the canonical data model.
The protocol consists of six layers:
- Identity Layer — DID-based identifiers for issuers and subjects (§14.5).
- Credential Layer — W3C-style Verifiable Credentials representing claims (§14.6, §14.7).
- Status Layer — Expiration, revocation, suspension, supersession (§14.11).
- Anchoring Layer — Optional public integrity anchors for timestamping and tamper evidence (§14.12.3).
- Aggregation Layer — Deterministic reputation and confidence computation across multiple credentials and attestations (§14.14).
- Presentation Layer — Wallet exports, recruiter APIs, selective disclosure (§14.18).
The Subject is the entity about whom a claim is made. A Subject MUST be identified by a DID or DID-compatible identifier.
{ "id": "did:key:z6MkUser123..." }A Primary Issuer is the single authority that originates and signs a credential. Each credential MUST have exactly one primary issuer:
|PrimaryIssuer(c)| = 1
A Co-Signer is an optional secondary signer that endorses the credential payload. A credential MAY have zero or more co-signers:
|CoSigners(c)| ≥ 0
Co-signers MUST NOT replace or obscure the primary issuer.
A Verifier is any system or agent that evaluates a credential or derived skill state. A Verifier MUST be able to perform validation without dependence on Alexandria-controlled endpoints.
An Attestor is an issuer of lightweight attestations such as peer validation, instructor endorsement, employer feedback, or DAO endorsement. Attestations MUST be represented distinctly from formal credentials.
Implementations MUST support at least one DID method and SHOULD support multiple. Recommended methods include did:key (required minimum) and additional pluggable methods such as did:ethr.
A DID document resolver MUST yield sufficient public key material to verify signatures.
v1 implementation note: the reference implementation ships did:key only (multicodec 0xed01 + multibase base58btc over an Ed25519 verification key; see §3.4). Additional DID methods are scoped for a future version. Parsers MUST reject unrecognised methods with a clear error rather than silently accepting them.
All credentials MUST be bound to a subject identifier. For credential c with subject s:
Subject(c) = s
This binding MUST NOT be alterable after issuance except through explicit supersession by a newly issued credential (§14.11.4).
A did:key resolves to the key in its identifier, always. There is no personal key rotation: no registry entry, gossip announcement or bundle can change how a did:key resolves, and a verifier MUST NOT consult a key registry for one. A key registry is consulted only for a DID method that is not self-resolving.
An organisation is identified by its domain: a DNS TXT descriptor (alexandria-org/1) lists the did:key identifiers allowed to sign for it. The credential's issuer MAY be an object whose id is the signing key's DID and which carries the organisation's name and domain, covered by the proof. Organisation backing is checked against the descriptor, which the verifier resolves and supplies: verified (with the descriptor's name and domain), key_not_listed, wrong_domain, invalid_descriptor or descriptor_not_supplied. Backing never changes the verification result. An organisation rotates by editing its key list; removing a key withdraws backing from everything that key signed, while the signatures still verify as plain keys. See ADR 0007.
The system defines the following credential classes.
High-weight claim representing successful completion, competency demonstration, or institutionally recognised achievement. Examples: course completion, skill certification, competency badge, research-contribution validation.
Credential issued based on measurable evaluation. SHOULD include score, rubric version, and assessment method.
Lightweight claim issued by peers, instructors, employers, or DAOs. MUST be weighted lower than formal credentials by default.
Credential asserting a governance role, teaching role, maintainer role, reviewer role, or evaluator role.
A computed artifact representing system-level aggregation or reputation. A DerivedCredential MUST NOT be confused with source-issued credentials — it is a computation over source evidence, not a replacement for it.
Each credential MUST conform to the following logical structure.
{
"@context": ["https://www.w3.org/ns/credentials/v2"],
"id": "urn:uuid:credential-id",
"type": ["VerifiableCredential", "FormalCredential"],
"issuer": "did:key:z6MkIssuer123",
"validFrom": "2026-04-13T00:00:00Z",
"validUntil": "2028-04-13T00:00:00Z",
"credentialSubject": {
"id": "did:key:z6MkSubject456",
"claim": {
"kind": "skill",
"skillId": "skill:logistics.network_optimization",
"level": 4,
"score": 0.87,
"evidenceRefs": ["urn:uuid:evidence-1", "urn:uuid:evidence-2"]
}
},
"credentialStatus": [
{
"id": "https://cloud.example/status-lists/did:key:z6MkIssuer123/1#271",
"type": "BitstringStatusListEntry",
"statusPurpose": "revocation",
"statusListIndex": "271",
"statusListCredential": "https://cloud.example/status-lists/did:key:z6MkIssuer123/1"
},
{
"id": "https://cloud.example/status-lists/did:key:z6MkIssuer123/2#271",
"type": "BitstringStatusListEntry",
"statusPurpose": "suspension",
"statusListIndex": "271",
"statusListCredential": "https://cloud.example/status-lists/did:key:z6MkIssuer123/2"
}
],
"termsOfUse": {
"policyVersion": "1.0",
"usage": "verification-permitted"
},
"integrity": {
"sessionId": "isess_...",
"status": "completed",
"integrityScore": 0.91,
"criticalCount": 0,
"warningCount": 1,
"assuranceLevel": "local",
"answerCustody": "device",
"generatedAt": "2026-04-13T00:00:00Z",
"trustProfile": "camera",
"verificationRung": "probed",
"coverageStatementDigest": "blake3:...",
"signalsRun": ["core", "camera"],
"signalsDegraded": ["camera"],
"signalsNotRun": ["device_attestation"],
"cameraCoverage": 0.95,
"probe": { "outcome": "satisfied", "policies": ["authored"], "satisfied": 2, "failed": 0, "skipped": 0 }
},
"relatedResource": [
{
"id": "https://cloud.example/coverage-statements/blake3:...",
"digestSRI": "sha256-...",
"mediaType": "application/json"
}
],
"proof": {
"type": "DataIntegrityProof",
"cryptosuite": "eddsa-jcs-2022",
"created": "2026-04-13T00:00:00Z",
"verificationMethod": "did:key:z6MkIssuer123#z6MkIssuer123",
"proofPurpose": "assertionMethod",
"proofValue": "z..."
}
}The envelope is a W3C Verifiable Credentials Data Model 2.0 credential. It
declares only the W3C v2 context; Alexandria's own terms (skillId, level,
score, evidenceRefs, integrity, witness, the credential classes) resolve
through that context's issuer-dependent default vocabulary, so a JSON-LD
processor expands the document without fetching anything that is not a W3C
document. The proof is a W3C Data Integrity proof using the eddsa-jcs-2022
cryptosuite. credentialStatus is one Bitstring Status List entry or a list;
Alexandria issues a revocation entry and a suspension entry at the same index
(§14.11). issuer is the DID string, or an object with the DID as id (§14.5.3).
relatedResource names the coverage statement again, at
{status host}/coverage-statements/{digest} (or
urn:alexandria:coverage-statement:{digest} without a status host), with a
digestSRI over the statement's bytes. A verifier MUST reject a credential
whose relatedResource names a statement other than the assertion's
coverageStatementDigest (coverageStatementMismatch). Every statement text
ever published stays resolvable offline from the verifier library's registry.
evidence (VC Data Model 2.0) carries at most one DeviceAttestationEvidence
entry when the session ran on an attested device or was backed by a companion
phone (§14.9.5). A role credential carries an AssessedCredentialEvidence
entry naming the credential it was issued on (§14.9.6), or, when it was issued
from a hosted attempt, a HostedAttemptEvidence entry naming the attempt
(§14.9.7). The example above, from a desktop without a companion phone,
carries none.
The optional integrity block is the Sentinel integrity attestation (§14.9.5). When present it is part of the signed envelope — the proof covers it, so the issuer attests to the figures and a verifier reads how the credential was earned, not merely that it was issued. Absent on credentials not backed by a monitored assessment session.
Each credential MUST include: id, type, issuer, validFrom, credentialSubject.id, proof.
Formal and assessment credentials SHOULD include: validUntil, credentialStatus, claim metadata, evidence references, and rubric or evaluation metadata where relevant.
A credential MUST have exactly one primary issuer:
∀c: |Issuer(c)| = 1
This is required to preserve revocation clarity, provenance, and accountability.
The same underlying skill or competency MAY be attested by multiple issuers. For a skill k, subject s, and issuer set I, there exist credentials c_1, c_2, …, c_n such that:
Skill(c_i) = k, Subject(c_i) = s, Issuer(c_i) ≠ Issuer(c_j) for i ≠ j
These credentials are independent attestations, not duplicates of a jointly owned truth.
A credential MAY include co-signers. If co-signers are present:
- the primary issuer MUST remain explicit
- each co-signer MUST supply its own proof
- verifiers MAY consider co-signers in trust scoring
Before issuance, the issuer MUST verify:
- subject DID validity
- claim schema validity
- evaluation completion if assessment-based
- evidence integrity
- policy compatibility
- issuer authorization to issue that credential type
A credential MAY be bound to a Sentinel integrity session at issuance. The request carries:
integritySessionId— theintegrity_sessions.idwhose terminal state backs the assessment.integrityPolicy(optional) — an issuance gate evaluated against that session.
When a session is bound, the issuer summarises its terminal state into the integrity attestation block (§14.7) and embeds it in the signed envelope. Every field is re-derived from the session at issuance, never copied from stored client text. The block carries:
| Field | Meaning |
|---|---|
sessionId |
The bound integrity_sessions.id |
status |
Terminal session status: completed, review, flagged or suspended (§12.5) |
integrityScore |
Descriptive composite score in [0,1], when the session recorded one |
criticalCount, warningCount |
Flag counts by severity |
assuranceLevel |
The device axis, below |
answerCustody |
Who held the answers during the attempt: device (the candidate's device) or issuer (the answers never left the issuer). The device always writes device; only an issuer writes issuer, for a hosted attempt (§14.9.7). Absent reads as device |
commitmentRoot |
Terminal root of the session's commitment chain |
generatedAt |
Issuance time |
trustProfile |
The profile the session was locked to: core, attested, camera or full. Absent when the session never selected one |
verificationRung |
The verification axis: none, process, probed, consistent or live (§12.6) |
coverageStatementDigest |
blake3: digest of the coverage statement for this profile and rung: what was checked, what was not, platform ceilings and certified error rates. Every statement states that monitoring cannot see a second person or a second device |
signalsRun |
Signal sets the profile ran: core, plus device_attestation and camera where included |
signalsDegraded |
Signals the profile ran that were lost: camera when camera coverage was incomplete, device_attestation when the stored attestation no longer verifies |
signalsNotRun |
Signal sets the profile does not include |
cameraCoverage |
Fraction of committed windows that carried camera checks, in [0,1]; 0 with no windows. Present only when the profile includes the camera, and absent from assertions issued before the field existed |
probe |
When a probe step ran: outcome (failed if any failed, else satisfied if any, else skipped), the policies used, and satisfied / failed / skipped counts |
The profile, rung, digest, signal lists, camera coverage, probe summary and answer custody are optional and omitted when empty. A verifier that re-serialises the typed credential to check its proof must know these fields, or it drops them and the proof fails (see the trust-profiles spec Notes on the alexandria-verify release).
assuranceLevel is one of:
-
"local"— privacy-first default. Figures are device-reported; under this level a determined attacker could suppress flags, so verifiers SHOULD weightlocalattestations accordingly. Levels form a ladder,local<companion_attested<device_attested: -
"companion_attested"— a desktop session backed by the learner's own attested phone, joined as a companion. A genuine app on the learner's phone was present and attested during the session; nothing is claimed about the desktop or what it showed. -
"device_attested"— the attempt ran in the attested app on the attested device: the issuing device's statement that it re-verified, at issuance, a platform attestation bound to the session: Apple App Attest (an attestation object chaining to Apple's App Attestation Root CA over the session nonce, plus an assertion by the attested key over the terminalcommitmentRoot) or Google Play Integrity (a classic token for the session nonce, decrypted and verified with the developer's response keys,PLAY_RECOGNIZEDandMEETS_DEVICE_INTEGRITY). The platform vouches that an unmodified build of the app on a genuine device produced the session; it does not vouch for the person. A desktop cannot attest itself (App Attest reports unsupported on every Mac) and never reaches this level. When Android attestation is enabled, this level requires the strong (hardware-backed) integrity verdict; the basic device verdict alone yieldslocal. -
"anchored"and"high_assurance"— reserved for a snapshot-commitment root anchored with a timestamp and immutability proof, and for an independently witnessed session. The implementation has no verified path to either, and a policy requiring a reserved level refuses issuance.
The session nonce is SHA-256("alexandria-device-attest-v1" ‖ 0x00 ‖ session_id ‖ 0x00 ‖ started_at). A stored level is never copied into a credential: the issuer recomputes the nonce and re-verifies the stored attestation, and embeds "local" when it does not verify. A companion phone's attestation is credited, as companion_attested, only when its binding names the issuing profile's own learner DID.
assuranceLevel is the issuing device's word. What a verifier relies on is the verified assurance level it establishes from the credential's DeviceAttestationEvidence entry, with trust inputs it supplies (Apple root, app identifiers, Play Integrity response keys). The entry is credential-bound when the platform signed the credential's binding digest, SHA-256(JCS({tag: "alexandria-attestation-binding-v1", commitmentRoot, subject, claim, integrity})) (an App Attest assertion by the session's key, or a Play Integrity token with the digest as nonce), and session-bound when it carries only the session's own attestation. The issuer obtains credential-bound evidence at issuance, asking a companion phone over the link when one backs the session, and falls back to session-bound when it cannot. The verifier reports attestation as not_supplied, verified_credential_bound, verified_session_bound, unverifiable (no trust inputs for that platform) or invalid with a reason code; invalid evidence rejects the credential. A verified outcome carries companion: true (omitted while false) when the entry has a companion binding. verifiedAssuranceLevel is companion_attested for verified credential-bound evidence with a companion binding, device_attested for verified credential-bound evidence without one, and local otherwise. See ADR 0006.
The integrityPolicy (IssuancePolicy, snake_case fields) bounds are each optional:
| Bound | Refuses issuance when | Code |
|---|---|---|
required_answer_custody |
The credited answer custody is below it (device < issuer). issuer is credited only on a role credential from a hosted attempt, an assertion stating issuer beside a HostedAttemptEvidence entry that says the issuer held the answers and graded (evaluate_hosted); evaluate and evaluate_assessed credit device whatever the assertion states, since anyone, a candidate with a second key among them, can sign an assertion stating issuer |
custody_below_required |
require_clean |
The status is not completed |
not_clean |
min_integrity |
The composite score is below it, or absent | integrity_below_minimum, no_integrity_score |
max_critical, max_warning |
A flag count exceeds it | too_many_critical, too_many_warnings |
required_assurance_level |
The verified assurance level is below it on the ladder. A minimum: local is met by every credential, companion_attested by verified credential-bound evidence with or without a companion binding, device_attested only by verified credential-bound evidence without one, reserved levels never |
assurance_below_required |
min_trust_profile |
The session's profile does not include every signal set the floor names (camera does not meet an attested floor). A signal counts when it is in signalsRun and not in signalsNotRun or signalsDegraded, with two refinements: a degraded camera still counts when cameraCoverage is from 0.9 to 1, and device attestation also needs evidence that verifies, credential- or session-bound, from the device the attempt ran on (companion evidence never credits it) |
trust_profile_below_floor |
min_verification_rung (the required rung) |
The credited rung is below it. A stated probed, consistent or live is credited only beside a probe step whose outcome is satisfied with satisfied > 0, failed = 0 and skipped = 0; otherwise the rule credits process, and the refusal names the credited rung |
rung_below_minimum |
probe_policy |
A policy other than none did not run, or a probe failed. A skipped probe is accepted; require a satisfied one with min_verification_rung: probed |
probe_policy_not_run, probe_failed |
The rule is judged over verifier-visible facts only (the policy, the integrity assertion and the attestation outcome) by one function, alexandria_verify::policy::evaluate, in the table's order (custody, status, score, flags, assurance, floor, rung, probes; custody first, since no retake of the same kind of attempt can meet it), so an issuing device, a hosted service and a candidate's picker reach the same answer. The issuing device additionally judges the floor when the attempt starts and refuses unless the two judgements agree. probe_connection_id names the model connection that writes generated probes under the llm policy; it is not judged at issuance. The camera coverage bound of earlier revisions (minCameraCoverage) is removed: coverage is now a property of the camera and full profiles. If any set bound is violated, issuance MUST be refused (no credential is minted); the issuer returns the first violated bound. A policy without a bound session is a request error. A bound session without a policy embeds the attestation but gates on nothing.
This makes a "trusted" credential one that was only minted when the assessment behind it satisfied the sponsor's integrity rules, with the evidence travelling inside the signed credential for any verifier to check.
An organization (sponsor) defines role assessments that map a job description to a backing assessment plus an issuance gate, so completing the assessment yields a trusted, role-specific credential:
Organization—{ id, name, owner_address, did? }. The sponsor's admin identity (stake address) owns the org.RoleAssessment—{ org_id, role_title, job_description, course_id?, skill_ids[], issuance_policy, required_assurance_level }. Theissuance_policyis the §14.9.5IssuancePolicy;required_assurance_levelis folded into it at issuance.AssessmentAttempt.role_assessment_id?— the published role a learner chose to assess for, fixed at the first start and reported back on resume. Learners list candidate roles withassessment_open_roles(skill_id); sponsors list a role's attempts withlist_role_attempts(role_assessment_id)and issue from one.
issue_role_credential(role_assessment_id, subject, integrity_session_id) is the keystone: it loads the role's policy, folds in the required assurance level, and issues a RoleCredential (claim { role: role_title, scope: org_name }) through the §14.9.5 gated pipeline — so the role credential is refused unless the bound integrity session satisfies the sponsor's rules, and carries the integrity attestation for verifiers. Issuance first requires that the session belongs to a graded, passed attempt for that role made by the named subject. When that attempt has its own AssessmentCredential, the role credential carries an AssessedCredentialEvidence entry naming it by id and integrity hash, with the attestation outcome and verified assurance level found for it, and the policy is judged from that entry (policy::evaluate_assessed). Candidates' devices hold the answers on this path, so every role made on a sponsor's device stores required_answer_custody: device and refuses issuer. A role requiring the live rung cannot yet issue here from a real interview: the candidate's live segment is recorded only in the interview's own check, never in the role attempt's session.
Organisation-issued credentials from the hosted service. A remote candidate answers an organisation's credential request (§14.18.4) from their own device. The hosted service verifies the share, including its attestation evidence, judges the role's policy with the same rule, and issues a RoleCredential signed with the organisation's hosted key under its domain-listed did:key, with an issuer object naming the organisation, the candidate's integrity assertion unchanged and an AssessedCredentialEvidence entry. It carries revocation and suspension entries in lists the service hosts for that key. This share path stays for roles that accept device custody; a role requiring issuer custody (the hosted service's default for a new role, with the probed rung) refuses it with custody_below_required and is taken as a hosted attempt (§14.9.7). The candidate's app collects it with the signed GET /api/credentials/for/{did}, verifies it and stores it like any received credential. See ADR 0008.
The policy in the request. A credential request MAY carry the organisation's issuance_policy (§14.18.4). Before an attempt answering it starts, exchange_prepare_assessment fetches the request, checks the organisation's proof, and stores the request as verified; exchange_start_assessment does so again, judges the request's floor before any item, and stores the policy on the attempt. Trust profile selection takes the floor from the stored request named by ProfileRequest.exchange_request_id (never together with a role). integrity_device_support reports whether this device can attest a session or pair a phone, so the request view can say up front when a floor is out of reach. exchange_credentials marks each shareable credential with meets_policy, refusal_code and refusal, judged by the shared rule; a refused credential stays shareable, but the organisation will not issue its own credential for it. Backing IPCs: create_organization, list_organizations, create_role_assessment, list_role_assessments, get_role_assessment, set_role_assessment_status, issue_role_credential, assessment_open_roles, list_role_attempts.
An organisation MAY hold a role's items and answers in its hosted service (a hosted item bank) and run the attempt itself. The service draws the items, sends one at a time, stamps its own clock on send and receipt, grades and probes; the candidate's device shows the items and contributes integrity evidence only. A score or timing the device reports decides nothing. See ADR 0009; the candidate API is specified in the Cloud repository's hosted attempts document.
- Items on the wire. A choice item carries
kind: "choice", the question, the options in this attempt's shuffled order andselect(oneormany). A plugin item carrieskind: "plugin",plugin: {cid, starter}naming a plugin the app bundles by its manifest's BLAKE3, the prompt asquestion, no options andselect: "submission"; the device answers withsubmission, and the issuer grades it with the exact bundled grader over hidden test cases the device never receives, full marks counting as correct. A device MUST refuse an item naming a plugin it does not bundle. Item text MUST stay in memory and out of storage and logs on the device. - Close. The device sends its integrity assertion and, on an attested phone, a credential-bound
DeviceAttestationEvidencewhose binding proof covers the close digestSHA-256("alexandria-hosted-attempt-close-v1" ‖ 0x00 ‖ commitmentRoot ‖ 0x00 ‖ did ‖ 0x00 ‖ attempt id)(attempt id lowercase hyphenated) instead of a credential's binding digest: an App Attest assertion over it, or a Play Integrity token with it as nonce. Evidence from a companion phone verifies ascompanion_attested. The issuer checks the evidence's certificates at its own clock when the attempt closes, never at the assertion'sgeneratedAt. On an attested role the close request itself carries an assertion from the registered key over its body, which holds the evidence. - Attested requests. When the role requires
device_attested, the open request registers an App Attest key (challengeSHA-256("alexandria-hosted-attempt-key-v1" ‖ 0x00 ‖ did ‖ 0x00 ‖ invite id ‖ 0x00 ‖ nonce)), and every answer and the close carry an assertion from it over the request's signed challenge, a newline and the hex SHA-256 of the body, with the counter advancing. A request without a valid assertion is refused. - Credential. When the policy is met (judged by
alexandria_verify::policy::evaluate_hosted), the issuer signs aRoleCredentialwhose assertion it writes: the device's session facts withanswerCustody: "issuer", the issuer's rung, probe step and verified level, and the coverage statement for that profile and rung. Its one evidence entry is aHostedAttemptEvidence:
{
"type": "HostedAttemptEvidence",
"attemptId": "…",
"answerCustody": "issuer",
"gradedBy": "issuer",
"score": 0.75,
"probe": { "outcome": "satisfied", "policies": ["authored"], "satisfied": 1, "failed": 0, "skipped": 0 },
"attestation": { "outcome": "verified_credential_bound", "platform": "ios" },
"verifiedAssuranceLevel": "device_attested"
}score is the fraction of drawn items the issuer graded correct, in [0,1] (omitted when it states none). probe is omitted when no probe step ran. The policy rule takes the verified level, the floor's device attestation and the probe step (for the probe policy and the rung) from this entry, and status, score, flags, profile and rung from the assertion; the assertion's custody counts only beside an entry that says the issuer held the answers and graded. The entry's level counts only as far as its own attestation verifies it. The entry is valid only on an issuer-signed credential whose assertion states issuer custody (§14.13.1). When the policy is not met the issuer records the first unmet requirement and issues nothing; a role requiring live is held until an interview for the candidate and role, conducted by the panel after the attempt closed, holds a live result. The issuer's grade must reach its pass mark whatever the policy asks, so a hosted attempt is never held to less than a shared credential, which exists only once its assessment passed. The rung is the issuer's own finding, never the device's: process from its own timing of every item it drew, probed from its own probe step, live from the panel; never consistent, which needs the learner's history on the device.
- Probes state their limit first. A probe is not sent with the answer that earns it: the reply carries the probe's time limit, and the probe's text is sent, and its clock started, only when the device asks for it after the candidate has seen the limit.
The protocol enforces semantic non-transferability, regardless of storage or wrapper format.
For any credential c bound to subject s, a verifier MUST reject any presentation where presenter identity p does not satisfy:
p = s OR p cryptographically controls s
If a credential is merely copied, wrapped, mirrored, or tokenized but cannot be bound to the presenting subject, it MUST NOT be accepted as valid proof of personal achievement.
A credential MAY include an expiration date. For verification time t_v and expiration time t_e:
Expired(c, t_v) = 1 if t_v > t_e
= 0 otherwise
If a credential is expired, the verifier MUST either reject it or downgrade its weight according to verifier policy.
Default protocol behavior: expired formal credentials SHOULD be treated as inactive unless explicitly allowed by policy.
Each revocable credential MUST provide a resolvable status reference. A credential is revoked if Revoked(c) = 1. Revoked credentials MUST NOT contribute positive weight to the active trust score.
The status reference is a Bitstring Status List entry: statusListIndex is a
bit position in the issuer's list, counted from the most significant bit of
each byte, and statusListCredential names the list. An Alexandria credential
carries two entries at the same index: revocation into the issuer's list
number 1 and suspension into list number 2 (§14.11.3). Lists are at least
131,072 bits. The credential bundle (§14.20) carries each list this node issues as a signed
BitstringStatusListCredential. Only the credential issuer may publish or
apply a status change for that credential. The implementation checks that the caller-derived DID matches both
the credential issuer and status-list issuer before changing the bitmap or
denormalized row.
Dereferenceable lists. When the issuer has a status host configured, the list is named by the URL the host serves it at:
{origin}/status-lists/{issuer DID}/{list number}
GET on that URL returns the current BitstringStatusListCredential
(Content-Type: application/vc, public, cacheable for a minute, readable
cross-origin), whose id is the same URL and whose issuer is the DID in the
path. The issuer publishes with PUT of the signed document to the same URL
whenever a bit changes; the host accepts it only if the document's id is that
URL, its issuer is the path's DID, its proof verifies against the key that DID
resolves to, and its validFrom is not older than the version already served
(a rollback is refused with 409). There is no account and no session: the
signature is the authorisation, so any party may relay an issuer's list and no
party may forge one. A verifier that fetches a list MUST apply the same checks
to what it receives before reading a bit; a list that fails them is not
evidence about the credential. A credential whose reference is a urn: names a
list that travels only in the credential bundle. Both forms verify offline from a
bundle; only the URL form verifies from the credential alone.
Gossip and fetched copies. A list gossiped on vc-status carries a
detached signature over (list_id, issuer, purpose, version, bits); the
canonical bytes are tagged alexandria-status-list-v2, so a list's purpose
is signed. A node applies a gossiped list only when its list_id names the
signing issuer (URL or URN form) and never over a row held under another
issuer. A node that fetches lists orders copies by their signed validFrom
and never writes a list its own profile issues from a fetch.
Suspension is temporary invalidation through the suspension status list, published, hosted and bundled exactly as the revocation list is. Suspend sets the credential's bit and reinstate clears it; a timed suspension is lifted by the issuer's node when its time comes. A verifier reads only the bit: a set bit is suspended, and a missing or unreachable suspension list is pending (suspension_list_missing, suspension_list_unavailable), never "not suspended". The issuer's local reason and end time are its own bookkeeping and are not consulted by verification. Suspended credentials MUST be excluded from positive active computations during suspension.
A newer credential MAY supersede an older one. For credentials c_old and c_new, if all four hold — same subject, same claim kind, same issuer, explicit supersession reference — then c_new supersedes c_old.
Superseded credentials MAY remain historically visible but SHOULD NOT be treated as the current active state.
Credentials MUST be delivered to a subject-controlled wallet or storage agent. Alexandria-controlled storage MAY exist for convenience but MUST NOT be the sole source required for future verification.
Implementations SHOULD support one or more of: local encrypted wallet storage, exportable JSON-LD packages, content-addressed backup, decentralised archival networks, user-controlled cloud backup.
Credential hashes SHOULD be anchored in a public integrity layer. Let H(c) be the canonical hash of credential c. An anchor MAY commit to many credentials at once through a Merkle root R over their hashes. If anchored, the anchor record MUST store:
A = (R, n, t_i, issuer_ref) with H(c) a leaf of the tree whose root is R
where n is the number of leaves and t_i the earliest issuance time among them. A batch of one is valid.
The tree is the RFC 6962 / RFC 9162 Merkle tree with BLAKE3 and domain separation. Leaves are the 32-byte H(c) values in batch order:
leaf(d) = BLAKE3(0x00 || d)
node(l, r) = BLAKE3(0x01 || l || r)
MTH({d}) = leaf(d)
MTH(D[n]) = node(MTH(D[0:k]), MTH(D[k:n])) k = largest power of two < n
An anchor receipt proves one credential's place in an anchored batch:
{ "v": 1, "leaf_index": i, "leaf_count": n, "path": [<hex>, …],
"root": <hex>, "tx_hash": <hex>, "issuer_did": <did> }
path is the RFC 9162 audit path for leaf i, ordered from the leaf up. A receipt is a sidecar: it is never embedded in the credential, so the credential's signature is unaffected. A verifier folds H(c) up the path with the RFC 9162 §2.1.3.2 algorithm and accepts the receipt only if it reaches root. The reference implementation (alexandria_verify::vc::anchor) carries worked examples for 1, 2, 3 and 5 leaves.
The full credential SHOULD NOT be stored on-chain unless explicitly required and privacy-compatible.
Stated explicitly because an implementer will otherwise assume the wrong canonicalization and build a verifier that disagrees with every other one.
Every credential carries a DataIntegrityProof with cryptosuite
eddsa-jcs-2022 (W3C VC Data Integrity 1.0; VC-DI-EdDSA 1.0 §3.3). The
signing input is, exactly as that specification states it:
proofConfig = proof without proofValue, plus the credential's @context
hashData = SHA-256(JCS(proofConfig)) || SHA-256(JCS(credential without proof))
proofValue = multibase-base58btc( Ed25519-sign(hashData) )
Canonicalization is JCS (RFC 8785), not JSON-LD canonicalization
(URDNA2015 / RDF Dataset Canonicalization). No JSON-LD expansion, no context
resolution, and no network fetch happens at any point in signing or
verification. verificationMethod is <issuer DID>#<fragment> — for
did:key, the key's own multibase identifier — and a verifier MUST reject a
method the issuer does not control.
@context is therefore declarative: it states which vocabulary the terms come
from, and it is covered by the signature like any other field, but nothing
processes it. A verifier needs JCS, SHA-256 and Ed25519, and nothing else —
which is also why any conforming Data Integrity verifier accepts the
credential as-is.
Two consequences worth being plain about. The context value must still be
correct, because a consumer that does process JSON-LD will act on it — and a
context that fails to define validUntil means a strict processor drops the
expiry and reads an expired credential as one that never expires. And a verifier
written against this section needs no JSON-LD tooling at all, which is most of
why an independent implementation is a few hundred lines rather than a project.
A credential is self-verifying in the common case: did:key embeds the issuer's
public key, so no lookup is needed and no service is consulted.
Two facts are not in the credential, and an implementer should know before meeting them in production rather than after.
Revocation and suspension. A credential says where its status lists live, not what they say. A verifier without a list cannot know. It MUST return a pending outcome that identifies the missing list; it MUST NOT accept the credential or label it revoked or suspended. An unavailable lookup and a confirmed missing list are distinct pending reasons.
An organisation's backing. The signature names a key, not an organisation. Whether an organisation stands behind the key needs its domain descriptor (§14.5.3), which the verifier resolves itself.
A credential bundle (§14.20) carries the status lists alongside the credentials, so it verifies entirely offline. A bare credential can still have its signature and signed claims checked, but a status-bearing credential remains pending until its lists are supplied. Neither fact requires contacting Alexandria: the lists come from the bundle or the issuer's status host, and the descriptor from the organisation's own domain.
The verifier MUST output a structured result:
{
"credentialId": "urn:uuid:credential-id",
"validSignature": true,
"issuerResolved": true,
"revoked": false,
"statusValid": true,
"expired": false,
"subjectBound": true,
"integrityAnchored": true,
"suspended": false,
"superseded": false,
"verificationTime": "2026-04-13T00:00:00Z",
"pendingReasons": [],
"attestation": { "outcome": "verified_credential_bound", "platform": "ios" },
"verifiedAssuranceLevel": "device_attested",
"acceptanceDecision": "accept"
}acceptanceDecision is one of accept, pending, or reject.
pendingReasons contains stable snake-case reason codes:
issuer_key_missing, issuer_key_unavailable, status_list_missing,
status_list_unavailable, suspension_list_missing,
suspension_list_unavailable, supersession_state_unavailable, and
integrity_anchor_unavailable. attestation and verifiedAssuranceLevel are
described in §14.9.5; coverageStatementMismatch (§14.7) appears only when
true. custodyDefects (omitted while empty) lists what is wrong with the
credential's answer custody, read from its own content; any one rejects:
issuer_custody_self_issued (a self-issued credential, issuer DID equal to
subject DID, states issuer), issuer_custody_unproven (a credential that is
not self-issued states issuer with no HostedAttemptEvidence entry: only a
hosted attempt shows the issuer held the answers, and a candidate's second key
is not self-issued by the DID test), hosted_attempt_self_issued (a self-issued
credential carries HostedAttemptEvidence), hosted_attempt_invalid (a
duplicate or unparsable entry, one not stating issuer custody and grader,
or one stating a score outside [0,1])
and hosted_attempt_custody_mismatch (the entry beside an assertion not
stating issuer). Trust classification (alexandria_verify::trust,
calculation version 6) recomputes them and calls a result that disagrees
inconsistent. statusValid is false when a present status
reference is malformed or its bit index lies outside the supplied list.
integrity_anchor_unavailable is reported only when the policy requires an
integrity anchor and the anchor lookup failed.
The shared verifier reads no chain. The caller supplies the credential's anchor
receipt (§14.12.3) together with what it observed of the transaction the receipt
names (§11.3.1): the recorded root, leaf count and issuer, and the transaction's
required signers. The verifier recomputes H(c) and sets integrityAnchored
only when the receipt folds from H(c) to its root, the root, leaf count and
transaction match the observation, the receipt and the observation both name
the credential's issuer, and the issuer's did:key key hash (Blake2b-224 of
its Ed25519 public key) is a required signer. A missing receipt leaves
integrityAnchored false, which rejects under a policy that requires it; a
receipt whose transaction has not been observed is pending under such a policy.
The application supplies receipts for credentials its node anchored and for
those that arrived with a bundle once their transaction is observed. A bundle
verified offline carries receipts but no observation, so it never claims an
anchor.
For credential c at verification time t_v, the verifier MUST perform these
checks. An implementation MAY reorder independent checks if it returns the same
facts and final classification:
- validate the credential envelope and bounded field shapes
- validate subject binding and applicable time fields
- resolve each referenced status-list bit (revocation and suspension)
- consult supersession state
- resolve the issuer key:
did:keyself-resolution, or a supplied key binding for a DID method that is not self-resolving - recompute the
eddsa-jcs-2022hash data and verifyproofValue - evaluate credential type, expiry, lifecycle, and integrity-anchor policy, the coverage statement cross-check (§14.7) and any attestation evidence (§14.9.5)
- emit all check facts, pending reason codes, and the decision
A malformed key, proof, status index, or other completed mandatory check is a rejection. Missing or unavailable data needed to finish a check is pending. Database or service failure MUST NOT be converted to a missing row or a clean active status.
Define the boolean components:
S(c)∈ {0,1} — signature validD(c)∈ {0,1} — issuer DID resolvableB(c)∈ {0,1} — subject binding validR(c)∈ {0,1} — revoked flag (1 means revoked)E(c)∈ {0,1} — expired flag (1 means expired)U(c)∈ {0,1} — suspended flag (1 means suspended)Q(c)∈ {0,1} — superseded flag (1 means superseded)X(c)∈ {0,1} — a present status reference is structurally validP(c)∈ {0,1} — all completed policy checks passC(c)∈ {0,1} — every required issuer, status, suspension, and supersession lookup is conclusive
Baseline classification:
ValidKnown(c) = S(c)=1 ∧ D(c)=1 ∧ B(c)=1 ∧ R(c)=0 ∧ X(c)=1 ∧ P(c)=1
Accept(c) if ValidKnown(c) ∧ C(c)=1
Pending(c) if no completed mandatory check failed ∧ C(c)=0
Reject(c) if any completed mandatory check failed
When issuer-key evidence is missing, signature verification is unperformed
rather than failed; this can therefore produce pending with
validSignature=false and issuerResolved=false. A known issuer key followed
by a bad signature is a rejection. Pending credentials MUST NOT enter active
aggregation or privilege evaluation.
Expiration, suspension, supersession, allowed credential classes, and required integrity anchoring MAY be policy-specific. The strict default rejects expired, suspended, and superseded credentials:
AcceptStrict(c) = 1 if Accept(c)=1 ∧ E(c)=0 ∧ U(c)=0 ∧ Q(c)=0
= 0 otherwise
The aggregation layer computes a Derived Skill State from a set of valid credentials and attestations. The protocol's central premise is:
issuance is local; trust is aggregated.
For a subject s and skill k, let the evidence set be:
E_{s,k} = { e_1, e_2, …, e_n }
Each evidence item e_i has: issuer I_i, raw score q_i ∈ [0,1], credential type τ_i, issuance time t_i, expiration time t_{e,i} (if applicable), revocation status, confidence metadata, evidence quality metadata.
Only accepted evidence (per §14.13) enters aggregation.
Each accepted evidence item receives an effective weight:
w_i = w_issuer,i × w_type,i × w_fresh,i × w_quality,i × w_independence,i
Each factor is defined in §14.14.4–§14.14.8.
Each issuer has a trust prior:
w_issuer,i ∈ [0,1]
This is a protocol- or verifier-configurable prior based on issuer credibility, governance legitimacy, auditability, historical accuracy, or role. Examples: a recognized institution carries a higher prior; a new peer attestor carries a lower one.
The protocol MUST keep issuer weighting transparent and explainable.
Authenticity and privilege are separate decisions. A valid credential from an
issuer outside the applicable subject/DAO qualification policy remains visible
and may receive a low verifier-defined trust weight, but MUST NOT satisfy a
proficiency-derived privilege such as field-opinion posting. A privilege check
MUST require an accepted issuer (or another route explicitly named by that
policy), the required skill and proficiency, and active status. This closes the
self-issued-course/two-identity route to privileges. Field-opinion posting
enforces this through subject qualification policies
(alexandria_verify::qualification): immutable documents identified by the
SHA-256 digest of their canonical bytes, accepted only when the network profile
pins that digest. A policy names its accepted issuers, minimum level, and
routes (accepted issuer, accepted course endorsement).
Credential class default weights SHOULD follow:
| Type | Weight |
|---|---|
| FormalCredential | 1.00 |
| AssessmentCredential | 0.90 |
| RoleCredential | 0.60 |
| AttestationCredential | 0.35 |
| SelfAssertion | 0.25 |
Weight follows verified provenance, not the declared type. A self-issued
credential (issuer = subject) takes the SelfAssertion weight whatever type
it declares, or an attested weight (0.30 in the reference implementation) when
its attestation evidence verified device_attested (a companion_attested
credential takes the SelfAssertion weight); only an issuer-signed
credential takes its declared type's weight. A suspended or flagged
session status removes a credential from aggregation only where the status is
reliable (issuer-signed, or device_attested evidence); elsewhere it is
ignored.
Implementations MAY tune these but MUST expose the chosen values.
Evidence SHOULD decay over time for fast-changing skills. Let t_v be the verification time, t_i the issuance time, Δt_i = t_v - t_i, and λ_k the decay constant for skill k. Then:
w_fresh,i = exp(-λ_k × Δt_i)
A smaller λ_k means slow decay; a larger λ_k means fast decay. Foundational mathematics: low decay. Fast-moving software framework: higher decay.
If explicit expiration exists and t_v > t_{e,i}, the credential SHOULD be treated as inactive unless policy says otherwise.
Evidence quality weight captures assessment rigor and evidence richness. Let:
- rubric completeness
r_i ∈ [0,1] - proctoring or anti-cheat reliability
a_i ∈ [0,1] - evidence traceability
x_i ∈ [0,1]
Then:
w_quality,i = α_r × r_i + α_a × a_i + α_x × x_i, subject to α_r + α_a + α_x = 1
Recommended defaults: α_r = 0.4, α_a = 0.3, α_x = 0.3 (see §14.25.3).
Multiple credentials from highly correlated issuers SHOULD NOT scale trust linearly. Let ρ_ij ∈ [0,1] be the dependence estimate between evidence items e_i and e_j, where 0 is independent and 1 is fully dependent (same origin in disguise). A practical independence discount for item i is:
w_independence,i = 1 / (1 + Σ_{j≠i} ρ_ij)
This reduces overweighting of repeated endorsements from the same trust cluster.
Each evidence item has a normalised score q_i ∈ [0,1]. Examples:
- percentage score:
q_i = percent / 100 - rubric level
L ∈ {1,2,3,4,5}:q_i = (L - 1) / 4 - pass/fail:
1or0
The system computes the weighted mean:
Q_{s,k} = Σ(w_i × q_i) / Σ(w_i)
where Q_{s,k} ∈ [0,1]. If Σ w_i = 0, no active score exists.
The total evidence mass is:
M_{s,k} = Σ w_i
This is not the same as score — it measures how much weighted evidence exists.
Confidence SHOULD increase with weighted evidence mass and issuer diversity. Let M_{s,k} be the evidence mass, U_{s,k} the number of unique effective issuer clusters, β > 0 the mass-saturation parameter, and γ > 0 the issuer-diversity parameter. Then:
C_{s,k} = (1 - exp(-β × M_{s,k})) × (1 - exp(-γ × U_{s,k}))
with C_{s,k} ∈ [0,1]. More evidence increases confidence; more diverse issuers increase confidence; confidence saturates rather than growing unbounded.
The final trust score combines quality and confidence:
T_{s,k} = Q_{s,k} × C_{s,k}
Q_{s,k} answers "how strong is the evidence?"; C_{s,k} answers "how sure are we?".
Continuous score MAY be mapped to discrete levels. Recommended 5-level mapping:
| Q range | Level |
|---|---|
| 0.00 ≤ Q < 0.20 | 1 |
| 0.20 ≤ Q < 0.40 | 2 |
| 0.40 ≤ Q < 0.60 | 3 |
| 0.60 ≤ Q < 0.80 | 4 |
| 0.80 ≤ Q ≤ 1.00 | 5 |
Implementations MAY use alternative thresholds but MUST publish them.
Attestation-based trust MUST NOT scale linearly with raw count. If multiple attestations originate from identities with low independence, the system MUST discount them.
A simple cluster-based cap is:
W_cluster = min(Σ_{i ∈ cluster} w_i, κ_cluster)
where κ_cluster is a maximum influence cap.
Self-assertions MAY exist for discovery or portfolio use but MUST have low default type weight (see §14.14.5) and MUST NOT alone generate high-confidence derived states.
Issuers with abnormally high pass rates or score inflation SHOULD be downweighted. Let μ_I be the issuer average awarded score, μ_G the global benchmark average for comparable assessment type, and σ_G the benchmark standard deviation. Define the inflation z-score:
z_I = (μ_I - μ_G) / σ_G
Then optional penalty:
p_I = 1 if z_I ≤ z_max
= exp(-η × (z_I - z_max)) if z_I > z_max
Adjusted issuer weight: w'_issuer,I = w_issuer,I × p_I.
If the same issuer repeatedly issues nearly identical credentials for the same claim without materially new evidence, implementations MAY count only the most recent or highest-quality active credential, or MAY strongly discount earlier ones.
v1 implementation note: the reference implementation does not yet enforce a re-issuance discount at the aggregation layer. The §14.11.4 supersession mechanism is the current means for an issuer to explicitly replace a prior credential; duplicate re-issuances without a supersession reference contribute independently to the evidence set and are bounded only by the §14.14.8 independence-weight discount when they share an issuer cluster.
The aggregation layer MUST produce an explainable object:
{
"subject": "did:key:z6MkSubject456",
"skillId": "skill:logistics.network_optimization",
"rawScore": 0.81,
"confidence": 0.74,
"trustScore": 0.5994,
"level": 5,
"evidenceMass": 3.92,
"uniqueIssuerClusters": 3,
"activeEvidenceCount": 5,
"calculationVersion": "1.1",
"sources": [
"urn:uuid:credential-1",
"urn:uuid:credential-2",
"urn:uuid:credential-3"
]
}External consumers often do not want raw credentials. They want answers to questions like: Does this person demonstrably possess skill k? At what level? With what confidence? Backed by whom? Based on how much evidence?
Therefore the protocol SHOULD support query responses of the form:
Response(s, k) = (L_{s,k}, Q_{s,k}, C_{s,k}, T_{s,k}, M_{s,k}, U_{s,k})
A consumer MAY define acceptance criteria such as Q_{s,k} ≥ q_min ∧ C_{s,k} ≥ c_min. Example hiring threshold: Q_{s,k} ≥ 0.75 ∧ C_{s,k} ≥ 0.65.
The system SHOULD support partial presentation of credentials. For example, a subject SHOULD be able to prove possession of a qualifying credential, achievement above a threshold, or current non-revoked status — without revealing unnecessary fields.
A presentation MAY reveal: credential existence only, issuer only, score only, level only, derived trust state only, or the full credential. Consumers SHOULD request the minimum data needed.
Schemas SHOULD be designed so that claim structures can later support zero-knowledge predicates such as Q_{s,k} ≥ 0.8 or L_{s,k} ≥ 4 without exposing raw underlying evidence.
A holder hands credentials to a verifier as a W3C Verifiable Presentation
(VC Data Model 2.0 §4.13): type includes VerifiablePresentation,
holder is the subject's DID, and verifiableCredential carries the
credentials — complete, or redacted under §14.18.2. The presentation is
secured with a holder DataIntegrityProof (eddsa-jcs-2022) whose
proofPurpose is authentication, whose challenge is the nonce the
verifier issued and whose domain is the verifier's audience, with created
and expires at most five minutes apart. A verifier MUST check all four
bindings and the holder's signature before reading anything the presentation
carries, and MUST record (domain, challenge) so the same presentation is
accepted once.
The credential exchange (§14.21) is one such presentation carrying exactly one
credential plus request (the organisation's request, under the holder's
signature) and, when the holder is also the issuer, issuerState. A request
MAY carry issuance_policy, the policy the organisation will judge the answer
against before issuing its own credential (§14.9.6). Being part of the request,
it is covered by the organisation's request proof and the holder's signature.
A request MUST NOT carry probe_connection_id; one that does is refused.
No NFT wrapper is implemented; credentials are not minted as NFTs. A presentation wrapper, if one is ever added, MUST NOT be the canonical credential record, MUST reference the canonical credential hash, and MUST NOT let a verifier skip subject binding (§14.10) or validation of the underlying credential; transfer of a wrapper MUST NOT imply transfer of achievement.
The protocol MUST remain minimally functional if Alexandria-controlled systems disappear. Let A = 0 denote Alexandria service death. Then for existing credentials c, the protocol aims to preserve:
Verify(c | A = 0) = 1
provided that: subject still possesses the credential, issuer DID remains resolvable or historically resolvable, signature suite remains supported, and status mechanism remains publicly available (if needed).
The following MUST survive Alexandria shutdown if the protocol is correctly implemented: credential possession by subjects, signature verification, subject-binding verification, optional integrity-anchor checking, historical evidence portability.
The following MAY degrade if Alexandria disappears: convenience APIs, hosted dashboards, centralised analytics, reputation recomputation services operated only by Alexandria, any revocation path that was improperly centralised.
Therefore, revocation and aggregation SHOULD be designed to be reproducible by third parties.
No credential issued under this protocol SHALL require Alexandria-controlled infrastructure as the sole means of later verification.
Input: issuer auth context, subject DID, claim payload, evidence refs, expiration policy, status configuration.
Output: signed credential, integrity hash, optional anchor receipt.
Input: credential or presentation, verification time, verifier policy.
Output: verification result structure (§14.13.1).
Input: subject DID, skill ID, accepted evidence set, weighting configuration, aggregation version.
Output: derived skill state (§14.16).
function verifyCredential(c, t_v, policy):
require schemaValid(c)
issuerDoc = resolveDID(c.issuer)
if issuerDoc == null:
return reject("issuer_unresolved")
if !verifySignature(c, issuerDoc):
return reject("bad_signature")
if !subjectBindingValid(c):
return reject("bad_subject_binding")
if isRevoked(c, t_v):
return reject("revoked")
if isExpired(c, t_v) and policy.rejectExpired:
return reject("expired")
if !policyCompatible(c, policy):
return reject("policy_incompatible")
return accept(metadata)
function aggregateSkillState(subject, skill, evidenceSet, t_v, config):
accepted = []
for e in evidenceSet:
if verifyCredential(e, t_v, config.policy).accepted:
accepted.append(e)
if len(accepted) == 0:
return noEvidenceState(subject, skill)
weightedScores = []
weights = []
for e in accepted:
q = normalizeScore(e)
wIssuer = issuerWeight(e.issuer, config)
wType = typeWeight(e.type, config)
wFresh = freshnessWeight(e, skill, t_v, config)
wQuality = qualityWeight(e, config)
wInd = independenceWeight(e, accepted, config)
w = wIssuer * wType * wFresh * wQuality * wInd
weightedScores.append(w * q)
weights.append(w)
Q = sum(weightedScores) / sum(weights)
M = sum(weights)
U = effectiveIssuerClusters(accepted, config)
C = (1 - exp(-config.beta * M)) * (1 - exp(-config.gamma * U))
T = Q * C
L = mapLevel(Q, config)
return {
subject, skill,
rawScore: Q, confidence: C, trustScore: T,
level: L, evidenceMass: M, uniqueIssuerClusters: U
}
Issuer private keys MUST NOT be exposed to application clients or untrusted agents.
All signing and verification flows MUST use deterministic canonicalization (e.g., RFC 8785 JCS) to prevent signature mismatch.
Credential IDs MUST be unique. Issuance time and proof creation time SHOULD be recorded. Where presentation tokens are used, they SHOULD include nonce and audience binding.
Issuers SHOULD log issuance metadata, rubric versions, and evidence references in auditable but privacy-compatible form.
A minimal viable Alexandria-compliant implementation MUST support:
- DID-backed subject identifiers
- exactly one primary issuer per credential
- signed VC issuance
- status checking
- expiration handling
- local verification without Alexandria dependency
- deterministic aggregation over multiple issuers for the same skill
- explainable output of score, confidence, and level
These defaults are suggested for v1.
| Type | Weight |
|---|---|
| FormalCredential | 1.00 |
| AssessmentCredential | 0.90 |
| RoleCredential | 0.60 |
| AttestationCredential | 0.35 |
| SelfAssertion | 0.25 |
Recommended decay constants per year-equivalent unit:
| Skill domain | λ |
|---|---|
| Foundational knowledge | 0.02 |
| Operational practices | 0.08 |
| Technical tools / frameworks | 0.15 |
Implementations MAY seed these values in an AggregationConfig-style per-skill table. The reference implementation ships a single global default of λ = 0.08 with per-skill overrides available through an opt-in skill_decay map; governance or per-taxonomy seeding of the three reference values above is an anticipated v1.1 extension.
Recommended: β = 0.6, γ = 0.7. Quality-weight component coefficients: α_r = 0.4, α_a = 0.3, α_x = 0.3.
Recommended threshold: z_max = 1.5, η = 0.5.
Assume subject s and skill k have three accepted evidence items.
Evidence 1 — formal credential, q_1 = 0.90:
w_1 = w_issuer,1 × w_type,1 × w_fresh,1 × w_quality,1 × w_independence,1
= 0.95 × 1.00 × 0.90 × 0.92 × 1.00
= 0.7866
Evidence 2 — assessment credential, q_2 = 0.78:
w_2 = 0.85 × 0.90 × 0.95 × 0.88 × 0.85 = 0.543609
Evidence 3 — attestation, q_3 = 0.80:
w_3 = 0.70 × 0.35 × 0.98 × 0.70 × 0.80 = 0.134456
Raw Score:
Q_{s,k} = (w_1 q_1 + w_2 q_2 + w_3 q_3) / (w_1 + w_2 + w_3)
= (0.7866·0.90 + 0.543609·0.78 + 0.134456·0.80) / 1.464665
= 1.240 / 1.464665
≈ 0.846
Evidence Mass: M_{s,k} = 1.464665. Assume U_{s,k} = 3, β = 0.6, γ = 0.7.
Confidence:
C_{s,k} = (1 - exp(-0.6 × 1.464665)) × (1 - exp(-0.7 × 3))
= (1 - exp(-0.878799)) × (1 - exp(-2.1))
≈ (1 - 0.415) × (1 - 0.122)
≈ 0.585 × 0.878
≈ 0.514
Trust Score: T_{s,k} = Q_{s,k} × C_{s,k} ≈ 0.846 × 0.514 ≈ 0.435.
Level: Using the §14.14.14 mapping, Q_{s,k} ≈ 0.846 ⇒ L_{s,k} = 5.
This yields strong underlying evidence quality, moderate confidence due to still-limited total evidence mass, and an elite provisional level with room for confidence growth. The reference implementation reproduces these numbers in tests/e2e_vc/aggregation.rs.
- Primary credentials MUST be VC-first, not NFT-first.
- The same credential MUST NOT be issued by multiple primary issuers.
- The same skill MAY be independently attested by multiple issuers.
- Trust MUST be aggregated from multiple accepted pieces of evidence.
- Aggregation MUST be deterministic, explainable, and non-destructive to source credentials.
- Credentials MUST remain verifiable without Alexandria-controlled infrastructure.
- NFTs MAY exist only as optional presentation wrappers and MUST NOT redefine credential ownership semantics.
- Attestations MUST be weighted lower than rigorous credentials by default.
- Freshness, issuer trust, evidence quality, and issuer independence SHOULD all affect aggregation.
- The system MUST be survivable, portable, and auditable.
This section is informative. It documents the architecture of the reference implementation to aid contributors and adopters. It does not define conformance requirements for the protocol.
The reference implementation is a Tauri v2 application — a single binary that bundles a Rust backend with a Vue 3 frontend. It runs on macOS, Linux, Windows, iOS, and Android.
| Component | Technology | Purpose |
|---|---|---|
| Backend | Rust (tokio) | Business logic, wallet, P2P, database, evidence, governance |
| Frontend | Vue 3, TypeScript, Tailwind CSS v4 | Pages, reusable components, and singleton composables |
| Database | SQLite (rusqlite, bundled) | Local encrypted store, 27 migrations |
| Content | iroh 1.0.2 / iroh-blobs 0.103 | BLAKE3 content-addressed blob store |
| P2P | libp2p 0.56 | Kademlia, GossipSub, Relay, DCUtR, request-response/CBOR for vc-fetch, sync, graph-fetch, profile-fetch, username-reg, guardian (/alexandria/guardian/1.0) |
| Wallet | pallas 0.35, Stronghold / AES-256-GCM | Conway era transactions, encrypted key storage |
| Cardano | pallas, Blockfrost | VC integrity anchoring (label 1697), completion-witness minting, stake-key registration, username anchoring (label 1698) |
| Integrity | Rust (candle) + TypeScript | Keystroke autoencoder (candle), mouse CNN (candle), face embedder (hand-written TypeScript LBP) |
| Tutoring | live (+ iroh-moq, moq-media) | Video + audio on desktop and mobile; screenshare desktop-only; opt-in on-device caption text over encrypted room gossip |
| CLI | Rust, clap 4 | Developer tooling (alexandria) |
| VC sign/verify | domain::vc/{mod,canonicalize,context,sign,status,verify} |
Data Integrity eddsa-jcs-2022 proofs over RFC 8785 JCS, Bitstring Status List, §14.7 / §14.13 |
| Trust aggregation | aggregation::{mod,weights,level,independence,antigaming,config} |
§14.14 engine + §14.15 anti-gaming; reproduces the §14.26 worked example |
| VC P2P layer | p2p::{vc_did,vc_status,vc_fetch,presentation,pinboard,archive} |
Wire layer for §14.5, §14.11.2, §14.18, §14.12.2 |
| VC storage | commands::{credentials,presentation,pinning,aggregation}; tables credentials, credential_status_lists, key_registry, credential_allowlist, credential_anchors, anchor_batches, anchor_receipts, anchor_observations |
Issuance, verification, revocation, suspension, allowlist, presentation envelopes, PinBoard commitments |
Engine: SQLite (rusqlite 0.38, bundled). Migrations: 27 — a baseline (migration 1) plus migrations 2–27, listed in db::schema::MIGRATIONS.
| Domain | Tables |
|---|---|
| Identity | local_identity |
| Taxonomy | subject_fields, subjects, skills, skill_prerequisites, skill_relations, taxonomy_versions |
| Courses | courses, course_chapters, course_elements, element_skill_tags |
| Learning | enrollments, element_progress, course_notes |
| Credentials | credentials, credential_status_lists, key_registry, credential_anchors, anchor_batches, anchor_receipts, anchor_observations |
| Reputation | reputation_assertions (derived from credentials), reputation_snapshots, reputation_snapshot_inputs |
| Integrity | integrity_sessions, integrity_snapshots |
| P2P | peers, pins, sync_log, catalog |
| Governance | governance_genesis_trust_anchors |
| Content | content_mappings |
| Sync | devices, sync_state, sync_queue |
| Completion | completion_claims, course_completion_endorsements, completion_observations, completion_witness_requests; exact policy/CID snapshots are stored on enrollments |
| Tutoring | tutoring_sessions |
| Interviews | interview_sessions, interview_participants, interview_criteria, interview_transcript_segments, interview_notes, interview_followups (local-only; not a global gossip or device-sync domain) |
| Classrooms | classrooms, classroom_members, classroom_join_requests, classroom_channels, classroom_messages, classroom_calls, classroom_group_keys |
| Settings | app_settings |
Key design decisions: deterministic IDs via hex(blake2b_256(parts.join("|"))), singleton identity table with CHECK (id = 1), content stored externally in iroh blobs.
The workspace has unit and integration coverage across crypto, db, p2p,
evidence, cardano, domain, aggregation, commands, and
content_store, including e2e_vc, guardian_e2e, and
settings_sync_e2e. The §14.26 worked example is locked in by
tests/e2e_vc/aggregation.rs.
p2p/stress.rs is a stub: there is no live P2P stress coverage. VC gossip
stress and credential-sync merge races are tracked there as follow-ups.
- [RFC 2119] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. https://www.rfc-editor.org/rfc/rfc2119
- [RFC 8785] Rundgren, A., Jordan, B., Erdtman, S., "JSON Canonicalization Scheme (JCS)", RFC 8785, June 2020 — used as the canonicalisation algorithm feeding signing and anchoring in §14.7, §14.12.3, §14.23.2. https://www.rfc-editor.org/rfc/rfc8785
- [W3C VC-DATA-MODEL] Sporny, M., Jones, T., Longley, D., et al., "Verifiable Credentials Data Model v2.0", W3C Recommendation, May 2025 — model underlying §14.6–§14.8. https://www.w3.org/TR/vc-data-model-2.0/
- [W3C VC-DATA-INTEGRITY] Sporny, M., Longley, D., Allen, G., et al., "Verifiable Credential Data Integrity 1.0", W3C Recommendation, May 2025 — proof envelope in §14.7. https://www.w3.org/TR/vc-data-integrity/
- [W3C VC-DI-EDDSA] Sporny, M., Longley, D., et al., "Data Integrity EdDSA Cryptosuites v1.0", W3C Recommendation, May 2025 — the
eddsa-jcs-2022cryptosuite in §14.12a. https://www.w3.org/TR/vc-di-eddsa/ - [did:key] Longley, D., Zundel, B., Sporny, M., "The did:key Method v0.7", W3C CCG Draft — DID method used in §14.5.1. https://w3c-ccg.github.io/did-key-spec/
- [W3C BITSTRING-STATUS-LIST] Sporny, M., Longley, D., et al., "Bitstring Status List v1.0", W3C Recommendation, May 2025 — revocation model in §14.11.2. https://www.w3.org/TR/vc-bitstring-status-list/
- [BIP-39] Palatinus, M., Rusnak, P., Voisine, A., Bowe, S., "Mnemonic code for generating deterministic keys", Bitcoin Improvement Proposal 39, 2013. https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki
- [CIP-30] Cardano Improvement Proposal 30, "Cardano dApp-Wallet Web Bridge", 2021. https://cips.cardano.org/cip/CIP-0030
- [CIP-1852] Cardano Improvement Proposal 1852, "HD Wallets for Cardano", 2019. https://cips.cardano.org/cip/CIP-1852
- [JSON Schema] Wright, A., Andrews, H., Hutton, B., Dennis, G., "JSON Schema: A Media Type for Describing JSON Documents", Internet-Draft, 2020. https://json-schema.org/draft/2020-12/schema
- [Bloom's Taxonomy] Anderson, L.W., Krathwohl, D.R. (Eds.), "A Taxonomy for Learning, Teaching, and Assessing", Longman, 2001.
- [ESCO] European Commission, "European Skills, Competences, Qualifications and Occupations". https://esco.ec.europa.eu
- [O*NET] U.S. Department of Labor, "O*NET OnLine". https://www.onetonline.org
- [iroh] number0, "iroh — Content-addressed data distribution". https://iroh.computer
- [libp2p] Protocol Labs, "libp2p — Modular peer-to-peer networking framework". https://libp2p.io
- [Cardano] Hoskinson, C., "Cardano", IOHK. https://cardano.org
- [Tauri] Tauri Contributors, "Tauri — Build desktop and mobile apps with web frontend". https://tauri.app
- [pallas] TxPipe, "Pallas — Cardano primitives in Rust". https://github.com/txpipe/pallas
- [BBS+] Decentralized Identity Foundation, "BBS+ Signatures v2023" — referenced from §14.18.3 for future zero-knowledge presentation compatibility. https://identity.foundation/bbs-signature/