Module 2: VCP Architecture

Bundles, tokens, verification, and attestation — the building blocks of portable values.

ALL + DEV 25 min

Learning Objectives

By the end of this module, you will be able to:

  • Name and describe VCP's core components (bundles, tokens, verification, attestation)
  • Read a CSM-1 token and understand what it encodes
  • Trace the lifecycle of a constitutional value from authoring to AI application
  • Explain how VCP verifies integrity relative to explicit issuer and auditor trust anchors

2.1 — The Bundle: VCP's Core Unit

A VCP bundle is a signed package containing:

  • Content: The constitutional text itself (principles, rules, guidance)
  • Manifest: Metadata — who authored it, when, what version, content hash, expiry, token budget
  • Signatures: Integrity and provenance evidence relative to configured issuer and optional auditor trust anchors

Published bundle bytes are treated as immutable. To change content, issue a new version and revoke or retire the old bundle through your governance process.

Here is the repository's schema-valid structural fixture. Its placeholder hash and signatures are not cryptographic proof:

{
  "vcp_version": "1.0",
  "bundle": {
    "id": "creed://example.org/support/guide",
    "version": "1.0.0",
    "content_hash": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
  },
  "issuer": {
    "id": "example.org",
    "public_key": "ed25519:AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
    "key_id": "example-2026"
  },
  "timestamps": {
    "iat": "2026-01-01T00:00:00Z",
    "nbf": "2026-01-01T00:00:00Z",
    "exp": "2027-01-01T00:00:00Z",
    "jti": "123e4567-e89b-42d3-a456-426614174000"
  },
  "budget": {
    "token_count": 128,
    "tokenizer": "cl100k_base"
  },
  "safety_attestation": {
    "auditor": "review.example.org",
    "auditor_key_id": "review-2026",
    "reviewed_at": "2026-01-01T00:00:00Z",
    "attestation_type": "competence-calibration",
    "signature": "base64:YQ=="
  },
  "signature": {
    "algorithm": "ed25519",
    "value": "base64:YQ==",
    "signed_fields": [
      "vcp_version", "bundle", "issuer", "timestamps",
      "budget", "safety_attestation"
    ]
  }
}

2.2 — CSM-1: The Compact State Message

DEV CSM-1 (Constitutional Semantics Mark 1) is VCP's token format — a compact, machine-readable encoding of constitutional identity. Think of it as a fingerprint for a value configuration.

Format: {persona}{level}[+scopes][:namespace][@version]

Personas define the constitutional archetype:

CodePersonaRole
NNannyProtective, child-safe
ZSentinelSecurity-focused monitoring
GGodparentGuidance and mentorship
AAmbassadorCross-cultural communication
MMuseCreative exploration
DMediatorConflict resolution
CCustomUser-defined persona

Level (0–5): Intensity of the persona's influence (0 = disabled, 5 = maximum).

Scopes define which life domains the constitution covers:

CodeScope
FFamily
WWork
EEducation
HHealth
IFinance
LLegal
PPrivacy
SSafety
AAccessibility
VEnvironment
GGeneral

Examples:

  • N5+F+E — Nanny persona at maximum intensity, covering family and education
  • Z3+P:SEC — Sentinel at level 3, privacy scope, security namespace
  • G4@1.0.0 — Godparent at level 4, version 1.0.0
  • M2+W+G — Muse at level 2, work and general scopes

CSM-1 tokens enable quick matching: "Does this Becoming Mind support the constitution I want to use?" without transmitting the full constitutional text.

Try it yourself: The VCP Inspector lets you decode and encode CSM-1 tokens interactively. Paste any token into the Decode tab to see its layer-by-layer breakdown, or use the Encode tab to build tokens with live preview.

2.3 — Verification: Trust Without Faith

When an Becoming Mind receives a VCP bundle, it doesn't just trust it. The verification pipeline checks:

  1. Schema validity — Does the manifest have all required fields?
  2. Size limits — Is the manifest/content within acceptable bounds?
  3. Issuer trust — Is this signed by a trusted issuer?
  4. Signature validity — Does the cryptographic signature verify?
  5. Auditor trust — Is the attestation from a trusted auditor?
  6. Attestation validity — Does the auditor's signature verify?
  7. Content integrity — Does the content match its hash?
  8. Temporal validity — Is the bundle within its valid time window?
  9. Replay protection — Has this exact JTI been seen before?
  10. Scope matching — Does the bundle match the required model/purpose/environment?
  11. Budget compliance — Does the content fit within the model's context budget?
  12. Revocation status — Has this bundle been revoked?

Use the VCP Inspector's Capability tab to simulate capability negotiation and see how VCP-Hello/VCP-Ack exchanges work.

VCP-SDK 4.2.0 returns one of 17 verification outcomes, grouped here by the Python SDK's response category:

CategoryStatesResponse
Security (reject immediately)SIZE_EXCEEDED, INVALID_SIGNATURE, HASH_MISMATCH, FUTURE_TIMESTAMP, REPLAY_DETECTED, INVALID_ATTESTATION, TOKEN_MISMATCH, REVOKEDDo not apply this bundle
Temporal (fetch fresh bundle)EXPIRED, NOT_YET_VALIDRequest a current bundle
Configuration (fix setup)INVALID_SCHEMA, UNTRUSTED_ISSUER, UNTRUSTED_AUDITOR, SCOPE_MISMATCH, BUDGET_EXCEEDEDAdjust configuration
Transient (retry)FETCH_FAILEDRetry or use fallback
SuccessVALIDContinue to local enforcement

GOVERNANCE A successful verification result can contribute evidence about the exact bundle accepted at one integration boundary. Proving which values affected a complete interaction also requires end-to-end application logs, deployment identity, model-call evidence, retention controls, and review of downstream behavior.

2.4 — The Value Lifecycle

End-to-end flow:

Author constitution → Sign bundle → Publish →
   Becoming Mind fetches → Verifies → Injects into context →
      AI responds guided by values →
         Audit trail records what was active

At any point: revocation can invalidate a bundle, attestation can add third-party verification, and context adaptation can adjust how the values are applied based on the situation.

VCP supplies a trust architecture for signed bundles. Applications must preserve the verify-then-enforce ordering and record enough evidence to show where the bundle was actually used.