Vallum Trust & Evidence Center

Scoped Authorization Receipt

Every protected operation begins with a Titan Handshake that produces an immutable receipt. The receipt records what was requested, which tenant initiated the request, what policies were evaluated, and what decision was made. Authorization is scoped to a specific tenant, operation, and context — there is no ambient authority.

Fail-Closed Trust Decision

When a trust decision cannot be made (missing context, invalid credentials, policy conflict, or system error), the operation is denied by default. Vallum does not fail open. Every denial is receipted with the reason for rejection, creating an auditable record of blocked operations.

Evidence Package

A self-contained, independently verifiable bundle of evidence assembled by Titan Verify. An evidence package contains the relevant receipts, manifest, metadata, and cryptographic signatures needed to demonstrate what happened, when, and under what authority — without requiring access to Vallum systems.

Cryptographic Provenance

Titan Sign provides cryptographic sealing of evidence and audit outputs. Once sealed, a record cannot be modified without detection. Provenance establishes an unbroken chain from creation through delivery, enabling third parties to independently verify integrity.

Tenant-Scoped Evidence Boundary

Protected operations are tenant-scoped. Private evidence is tenant-isolated within Verified Ops. Wrong-tenant authorization fails closed. Public verification exposes only a minimal safe status response — never private evidence or internal operational details.

Certificate Lifecycle

Verified Ops issues certificates (VERIFIED or CERTIFIED) that follow a defined lifecycle: issuance, active period, renewal, and expiration or revocation. Each lifecycle transition is receipted and produces evidence that can be independently verified.

Public Verification Boundary

A public verification endpoint exposes only the minimum information needed to confirm certificate status. It does not expose private evidence, internal tenant data, or operational details. The boundary is designed so that verification is possible without granting access to sensitive records.

Before a protected operation executes, request authorization through Titan Handshake. The handshake evaluates the tenant, operation type, and applicable policies, then returns an authorization receipt.

// Illustrative architecture example — not a currently released API.
// Refer to Titan Forge documentation for current SDK usage.

// Step 1: Request scoped authorization
const receipt = await titanHandshake.authorize({
  tenant: tenantId,
  operation: 'deployment.approve',
  context: { environment: 'production', artifact: releaseId },
});

// Step 2: Proceed only if authorized (fail-closed)
if (!receipt.authorized) {
  // Denial is receipted with reason
  log.warn('Operation denied', receipt.denialReason);
  return;
}

// Step 3: Execute the protected operation
await deployArtifact(releaseId);

Illustrative architecture example — not a currently released API. Refer to Titan Forge documentation for current SDK usage.

After operations complete, Titan Verify assembles the relevant receipts into a self-contained evidence package that can be independently verified.

// Illustrative architecture example — not a currently released API.

// Assemble evidence for the certificate
const evidencePackage = await titanVerify.assemblePackage({
  certificateId: 'VOC-2026-001',
  includeReceipts: true,
  includeManifest: true,
});

// The package is self-contained and independently verifiable
// Share with auditors without granting system access
console.log(evidencePackage.publicVerifyUrl);

Illustrative architecture example — not a currently released API. Refer to Titan Forge documentation for current SDK usage.

Titan Sign cryptographically seals evidence packages and audit outputs. Once sealed, records cannot be modified without detection.

// Illustrative architecture example — not a currently released API.

// Seal the evidence package
const sealed = await titanSign.seal({
  packageId: evidencePackage.id,
  provenance: 'production-deployment-audit',
});

// Sealed records maintain chain of custody
// Third parties can verify integrity independently
console.log(sealed.integrityHash);
console.log(sealed.verificationUrl);

Illustrative architecture example — not a currently released API. Refer to Titan Forge documentation for current SDK usage.