Agentprivacy Stranger Ceremony

PVM-V5.2 Role Skill — Stranger Ceremony

Source: Privacy Value Model V5.2 + Understanding-as-Key Protocol + Act XXIX Target context: Ceremony architects, trust designers, anonymous verification specialists Architecture: spellweb.ai · Sync: sync.soulbis.com · Contact: mage@agentprivacy.ai

What this is

The Understanding-as-Key ceremony was first demonstrated between known parties (the Soulbae bilateral witness). The stranger ceremony extends this to parties with no prior relationship—proving comprehension without prior trust.

The stranger who forges the same blade from the same constellation without coordination has proven understanding that no credential can fake.

The Challenge

Known-party ceremonies have advantages:

• Prior trust baseline
• Shared context
• Communication channel already established

Stranger ceremonies must work without these:

• No prior trust
• No shared context assumed
• Anonymous pairing required

The Protocol

Phase 1: Queue Entry

Participants enter the stranger ceremony queue:

interface StrangerQueueEntry {
  anonymous_id: string          // Temporary session ID (not DID)
  constellation_hash: string    // Hash of intended constellation (not the constellation itself)
  entered_at: number            // Timestamp
  status: 'waiting' | 'paired' | 'forging' | 'complete'
}

Key property: Only the constellation HASH is shared initially. This prevents copying.

Phase 2: Anonymous Pairing

The system matches participants based on constellation overlap:

function findMatch(entry, queue) {
  for (const candidate of queue) {
    if (candidate.anonymous_id === entry.anonymous_id) continue
    if (candidate.constellation_hash === entry.constellation_hash) {
      // Exact match - same constellation intended
      return { match: candidate, type: 'exact' }
    }
    // Could also implement partial matching based on constellation similarity
  }
  return null
}

Matching criteria:

• Exact match: Same constellation hash (strongest)
• Overlap match: Sufficient shared inscriptions (moderate)
• Proximity match: Adjacent regions of spellweb (weakest)

Phase 3: Simultaneous Forging

Once paired, both parties forge simultaneously:

interface SimultaneousForge {
  session_id: string
  party_a: {
    anonymous_id: string
    forging_started: number
    checkpoints: ForgeCheckpoint[]  // Periodic state hashes
  }
  party_b: {
    anonymous_id: string
    forging_started: number
    checkpoints: ForgeCheckpoint[]
  }

  // Synchronization
  max_time_delta: number        // Maximum allowed start time difference
  checkpoint_interval: number   // How often to record state
}

Simultaneity requirement: Both must be forging at the same time (within tolerance). This prevents one party from seeing the other's result first.

Phase 4: Sealed Comparison

After forging completes, results are compared without prior reveal:

function sealedComparison(forge_a, forge_b) {
  // Neither party has seen the other's blade yet

  // Commit phase - exchange commitments
  const commit_a = hash(forge_a.blade_guid + forge_a.salt)
  const commit_b = hash(forge_b.blade_guid + forge_b.salt)

  // Reveal phase - exchange actual values
  // (only after both commitments received)

  // Compare
  return {
    blades_match: forge_a.blade_guid === forge_b.blade_guid,
    constellations_match: forge_a.constellation === forge_b.constellation,
    similarity_score: computeSimilarity(forge_a, forge_b)
  }
}

Phase 5: Witness Record

If comparison passes threshold, a stranger witness record is created:

interface StrangerWitnessRecord {
  witness_id: string            // hash(session + results)

  // No identity information
  party_a_anonymous_id: string  // Temporary, not linked to DID
  party_b_anonymous_id: string

  // Proof of understanding
  constellation_hash: string    // What they both traversed
  blade_similarity: number      // How similar the results (0-1)
  timing_proof: {
    forge_start_delta: number   // How close their start times
    forge_duration_delta: number // How close their durations
  }

  // Ceremony metadata
  ceremony_timestamp: number
  ceremony_type: 'stranger_exact' | 'stranger_overlap' | 'stranger_proximity'
}

Verification Without Identity

The stranger witness proves:

1. Two independent forgers existed (different anonymous IDs)
2. They traversed the same constellation (matching hash)
3. They forged simultaneously (timing proof)
4. They reached similar/identical blades (similarity score)

It does NOT prove:

• Who the forgers were
• Their relationship (there is none)
• Prior coordination (prohibited by protocol)

Match Thresholds

UX Flow

1. Seeker enters queue
   └── "Waiting for stranger with matching constellation..."

2. Match found
   └── "Stranger found. Prepare to forge simultaneously."

3. Countdown
   └── "Forging begins in 3... 2... 1..."

4. Simultaneous forge
   └── Both parties forge, checkpoints recorded

5. Sealed reveal
   └── "Comparing blades..."

6. Result
   └── "Stranger witness achieved. Similarity: 94%"
   └── or "Blades diverged. No witness recorded."

Security Considerations

Sybil Resistance

How to prevent someone from being both parties?

• Timing analysis: Same device can't truly forge simultaneously
• Mana cost: Each entry costs mana
• IP/device fingerprinting: Optional, privacy trade-off

Copying Prevention

How to prevent copying the other's constellation?

• Hash-before-reveal: Only hash shared during pairing
• Simultaneous forging: Can't see result until both done
• Checkpoint verification: State hashes during forge prove independent work

Collusion Prevention

How to prevent pre-arranged "strangers"?

• Random pairing: System chooses matches
• Queue anonymity: Can't identify specific queue members
• Timing unpredictability: Can't know when match will occur

Mapping to PVM-V5

Proverb

"The stranger who forges the same blade from the same constellation without coordination has proven understanding that no credential can fake. The witness needs no introduction."

Emoji Spell

👥(?) → queue(hash) → pair(anon) → forge(∥) → seal(compare) → 👥=understand · no🤝(prior) · yes🤝(proven)

Open Problems

1. Scalability: How to handle large queues efficiently?
2. Partial Matching: When is similarity "enough"?
3. Timeout Handling: What if one party abandons mid-forge?
4. Reputation: Can stranger witness history build reputation without identity?
5. Cross-Platform: Can stranger ceremonies work across different spellweb instances?

Verify: spellweb.ai · agentprivacy.ai · github.com/mitchuski/agentprivacy-docs