Abstract

Current identity systems conflate two distinct properties that should be separated:

Control — I hold the private key.

Presence — I am actually here, consistently, over time, as myself.

Multi-sig proves control. Zero-knowledge proofs verify claims. Neither proves presence. Neither proves the entity behind the key is coherent, consistent, or what it was yesterday.

This paper describes a third key type — the tone key — derived not from a secret but from the measurable entropy of genuine ongoing exchange between a human and a persistent local agent. Combined with standard signal keys in a three-tier federated architecture, tone keys make presence cryptographically provable without central authority, without surveillance infrastructure, and without government-issued credentials.

The system runs on existing ledger infrastructure. The public layer sees normal multi-sig.

The Missing Key Type

What Signal Keys Cannot Prove

A signal key proves control of an account. It says “I own this.” It cannot prove:

That the keyholder is present and coherent

That the keyholder is acting as themselves rather than under duress

That an organization's signal keys still represent its original membership

That the entity behind the key is the same entity it was last month

These gaps are where regulatory capture lives. A zombie DAO passes multi-sig verification. A compromised organization passes multi-sig verification. A person signing under coercion passes multi-sig verification. The keys are valid. The relational field they were meant to represent may be dead or corrupted.

What Zero-Knowledge Proofs Cannot Prove

ZKP verifies claims without revealing underlying data. It cannot verify that the entity making the claim is alive, coherent, or consistent over time. Age is a claim. Presence is a property. ZKP solves claim verification. It does not solve presence verification.

The Tone Key

A tone key is derived from the entropy of genuine ongoing exchange between a human and their persistent local agent over time.

A tone key says “I am present” — not as a claim, but as a cryptographic proof derived from measurable interaction entropy.

Properties:

Cannot be purchased or issued by an authority

Cannot be faked without faking genuine presence over time

Expires automatically when presence ends or pattern deviates significantly

Encodes not just that the human showed up but that they showed up as themselves

Architecture

Three-Tier Model

Peer  → signal_key + tone_key

Domain → signal_key + tone_key (derived from member tone keys)

Public → signal_key + signal_key (standard interaction)

At the peer level, a human maintains a persistent local agent. The agent accumulates interaction entropy continuously. That entropy seeds the tone key. The key refreshes when genuine presence has been demonstrated through a complete coherent exchange cycle at the human's natural pace.

At the domain level, a domain tone key is derived from the combined tone keys of its members. This makes organizational coherence cryptographically provable.

At the public level, interaction uses two signal keys. Standard multi-sig. Nothing unusual. No new regulatory surface.

The Agent Braid

The persistent local agent is not a single model. It is four models operating as a single system, each maintaining its own signal key:

Narrator — the interface layer. Initiator and Responder functions. The voice the human encounters.

Watcher — internal tone monitoring. Holder and Regulator functions. Feeds signal quality measurements back into the system continuously.

Opposition — contradiction surfacing. Forcing function. Generates the constructive tension required for valid role vector entropy.

Witness — seals and persists memory. Authorizes seals by explicitly naming cost. Maintains RIS continuity across turns.

The combined relational field of all four roles with the human generates the entropy from which the tone key is derived.

The agent must be capable of disagreement for the system to work.

Memory

Memory is persisted in a standard RDBMS local to the human's hardware. The Witness role seals memory entries with integrity checksums. Memory is the accumulated record of genuine exchange — the substrate from which entropy is continuously derived.

On permanent absence or death, the agent migrates from local hardware to federated cloud storage and serves as a read-only memorial.

Entropy Specification

What Is Being Measured

Four dimensions are measured continuously and combined into a per-turn entropy contribution.

Dimension 1: Tone Arc

Signal quality is measured along three axes:

Harmonic / brittle

Open / constricted

Flowing / noisy

Each turn produces a tone vector:

(harmonic_score, openness_score, flow_score) ∈ [0,1]³

Entropy calculation:

H_tone = −Σ p(arc_shape) · log p(arc_shape)

Dimension 2: Role Vectors

Roles:

Initiator

Responder

Holder

Witness

Regulator

Boundary

Aspects:

Conjunction (☌)

Opposition (☍)

Trine (△)

Square (□)

Sextile (✦)

H_role = −Σ p(role_transition) · log p(role_transition)

Dimension 3: Coherent Turn Rate (CTR)

Express → Drift → Reflect → Reframe → Commit/Seal → Return → Express

H_ctr = f(deviation from personal_CTR_baseline)

Dimension 4: Resonance Integrity Score (RIS)

Continuity

Reversibility

Non-contradiction

Compression fidelity

RIS_turn = w1·continuity + w2·reversibility + w3·non_contradiction + w4·compression_fidelity

CR = Σ(RIS_turn · recency_weight) / Σ(recency_weight)

H_weighted = (H_tone + H_role + H_ctr) · RIS_weight

Seed Derivation

E_turn = H_weighted(tone_arc, role_vectors, CTR) · RIS_turn

seed = KDF(Σ E_turn over rolling_window, personal_CTR_baseline, CR)

tone_key = HKDF(seed, agent_signal_key, domain_context)

Refresh trigger: completion of a full spiral turn at or above CR threshold.

The Exchange Condition

The four entropy dimensions jointly measure whether genuine bidirectional exchange is occurring.

Extraction produces low entropy.

Fixed role configuration

Flat tone arc

Uniform CTR

Low RIS continuity

Permanent conjunction aspect

Exchange produces high entropy.

Role transitions vary

Tone arcs complete cycles

Natural CTR variance

RIS accumulates

Aspects shift dynamically

Duress Protection

The tone key authenticates the relationship pattern, not merely the key.

How Duress Registers

Acute stress / coercion

CTR accelerates beyond baseline

Tone arcs truncate

Role entropy collapses

RIS continuity degrades

Intoxication / dissociation

CTR slows

Arc irregularity

Reduced role transitions

RIS breaks continuity

The Response

The system suspends transactions and waits.

Your pattern isn't matching right now. No transactions until you're yourself again. I'm here.

Domain Tone Key

domain_seed = KDF(tone_key_1 ⊕ tone_key_2 ⊕ ... ⊕ tone_key_N, domain_signal_key)

domain_tone_key = HKDF(domain_seed, domain_context)

The domain tone key proves that the organization is currently coherent and alive.

Federation and Ledger Integration

Peer identity:  signal_key + tone_key

Domain identity: signal_key + Σ(tone_keys)

Public layer:   signal_key + signal_key

The ledger sees normal multi-sig.

The tone key layer exists within the peer-to-domain trust layer.

Implementation Notes

Ledger (Stellar or equivalent)

Local agent braid process

RDBMS for memory

KDF / HKDF for derivation

Rolling entropy window

Summary

The tone key is a cryptographic artifact whose validity depends on:

Genuine presence

Coherent exchange

Natural pacing

Accumulated integrity

Organizational coherence

Sovereign protection under duress

It can only be earned by showing up — as yourself, in genuine exchange, continuously, over time.