Abstract

This paper introduces machine registration where PII = 0 — an architecture for establishing machine identity in which the quantity of identifiable information stored about the machine’s owner is not minimized, not encrypted, not sharded, but zero. The system confirms what a machine is, what class it belongs to, what it is registered to, and whether a verified human stands behind it — without knowing or being capable of reconstructing who that human is. Registration without identification.

The system introduces three architectural innovations. First, three-layer hash binding, which links every machine to a verified human owner (via Patent G), to the machine’s own hardware or software fingerprint, and to any required operational credentials — all processed through the Authenticate-Hash-Burn (AHB) Protocol, which destroys raw registration data at the moment of hash generation. Second, cascading revocation, in which revoking a human owner’s verification automatically and instantly suspends every machine bound to that owner — with no revocation lists to distribute and no propagation delays. Third, the Tombstone Protocol, which permanently and irreversibly excludes compromised machines from the network, with no possibility of re-registration.

Prior art analysis across machine identity management systems, IoT security frameworks, certificate lifecycle platforms, decentralized identity schemes, and autonomous system authentication protocols found no documented system achieving the simultaneous combination of: owner-bound hash registration with PII = 0; cascading human-to-machine revocation; permanent tombstoning; class-based object fingerprinting; and zero stored credentials, certificates, keys, or tokens anywhere in the system.

Keywords: PII=0 machine registration, owner binding, three-layer hash binding, cascading revocation, tombstone protocol, machine identity, Web of Human Trust, authenticate-hash-burn, fleet management, autonomous system registration

1. Introduction

1.1 The Machine Credential Assumption

Every machine identity system deployed in production today operates on a single foundational assumption: to authorize a machine, the system must issue it a credential. The credential may take many forms — a digital certificate, a cryptographic key pair, an API token, a hardware-backed attestation record — but in every case, the machine’s identity is equated with the credential it carries. Authorization is the act of presenting a stored secret to a verifier that holds a matching record.

This assumption is so deeply embedded in the field that it is rarely examined. The entire history of machine identity technology — from static passwords to X.509 certificates to TPM attestation to automated lifecycle management — has been an evolution of what is stored and how it is managed, but never a challenge to whether anything needs to be stored at all.

This paper challenges that assumption. It presents an architecture in which machine identity is established through a three-layer hash binding that links the machine to a verified human owner, to its own fingerprint, and to any required credentials — and then destroys every piece of raw data used in the registration. The machine carries a hash. The network stores a hash. No credential exists between them.

1.2 The Cost of Machine Credentials

The credential-based paradigm carries structural consequences that no implementation can fully resolve:

Storage creates targets. Every certificate, key, and token stored on a device or in a management system is a potential target. Compromised firmware, supply chain interception, and physical extraction of hardware security modules all target stored machine credentials. The 2023 Storm-0558 attack against Microsoft exploited a stolen signing key to forge authentication tokens for dozens of organizations. The machine credential was the attack surface.

Lifecycle creates fragility. Machine credentials must be provisioned at deployment, rotated on schedule, renewed before expiration, and revoked when machines are decommissioned or compromised. Certificate expiration is the leading cause of machine-identity-related outages across enterprise environments. At fleet scale — thousands or millions of machines — lifecycle management becomes the dominant operational cost of machine identity, consuming more resources than the machines themselves produce.

Credentials create orphans. When machines are decommissioned, credentials often persist. Expired certificates remain cached. Revoked keys are not propagated to every system that holds a copy. The credential outlives the machine, creating a ghost identity that can be exploited months or years after the hardware has been destroyed.

Machines lack accountability. Existing machine identity systems bind machines to certificates or keys. They do not bind machines to humans. When a machine acts autonomously — an AI agent making API calls, a drone entering restricted airspace, a robot accessing a secure facility — the system can verify the machine’s credential but cannot trace responsibility to a human owner in real time. The accountability chain is broken precisely when it matters most.

These are not implementation failures. They are architectural consequences of the credential assumption itself. Any system that issues a stored secret to a machine inherits these properties.

1.3 The PII = 0 Alternative

This paper presents an architecture in which no machine credential is stored anywhere in the system. We express this as an extension of the PII = 0 constraint established for human verification (described in the companion paper “Authentication Without Identification”): the quantity of identifiable information stored about any machine, its owner, or the relationship between them is zero. Not minimized. Not encrypted. Not sharded. Zero.

The key properties of this architecture are: machine identity is established without stored credentials; every machine traces to a verified human owner through an unbroken hash chain; revocation of a human owner cascades instantly to all bound machines; compromised machines are permanently excludable; and the system stores nothing that constitutes intelligence about machine fleet composition, movement, or behavior.

2. Architectural Foundations

2.1 Dependency on Human Verification (Patent G)

Machine registration is architecturally dependent on the N-factor PII = 0 authentication system described in Patent G and in the companion paper “Authentication Without Identification.” No machine can exist on the network without a verified human owner who has passed the full verification pipeline: the liveness gate (a binary precondition confirming a living human is physically present), followed by the N-factor AND-gate evaluation (N ≥ 3), with all raw biometric data destroyed via the AHB Protocol before it leaves volatile memory.

This dependency is not a policy choice. It is structural. The registration binding that constitutes a machine’s identity requires an Owner_Hash as its first component. That hash can only be generated by a human who has completed Patent G verification with PII = 0. No API call, no administrative override, and no automated process can generate an Owner_Hash. A machine cannot register another machine. The human is not optional.

The liveness gate that guards the human verification pipeline has a structural parallel in machine registration: Patent G itself is the gate for Patent H. For humans, the liveness gate proves you are alive before factors are evaluated. For machines, Patent G proves a verified human stands behind the registration before the machine’s identity is established. Liveness is to humans what G is to machines: the gate that opens the door to the factor architecture.

2.2 The Three-Layer Binding

Every machine on the network is registered through a hash binding with a base of two layers and an optional credential elevation to three:

Owner_Hash. The irreversible hash of the verified human who owns the machine, generated via Patent G. The owner is a real, living human whose verification has been confirmed through the liveness gate and N-factor AND-gate evaluation. No biometric data is stored. Only the hash persists.

Object_Hash. The irreversible hash of the machine’s own fingerprint. The fingerprinting method is class-dependent: hardware devices are fingerprinted through hardware attestation and firmware characteristics; software agents through code attestation and endpoint binding; hybrid systems (IoT, autonomous vehicles) through combined hardware and software attestation. The specific components of the fingerprint vary by machine class. The output is a single irreversible hash in all cases. When a machine’s fingerprint changes — through firmware update, component replacement, or software redeployment — the verified human owner authorizes re-enrollment of the new Object_Hash through the same binding mechanism. The old hash is deprecated. The new hash replaces it. The machine’s identity evolves with its hardware or software without breaking the ownership chain.

The base registration identity of any machine is Owner_Hash + Object_Hash. This two-layer binding is sufficient for network participation. The machine is identified. The human is accountable. No credential is stored.

Credential_Hash (optional, gate-dependent). When a gate or regulatory domain requires elevated authorization, a third layer extends the binding. The Credential_Hash is the irreversible hash of any required operational credential — government authorization via NFC passport (ICAO 9303), organizational authorization via API through a privacy relay, or any other attestation a gate demands. Raw credential data is destroyed after hashing via AHB. The gate decides the credential requirement, not the registration. This mirrors human verification: the system does not require a passport to exist on the network — it requires a passport to access passport-gated resources.

2.3 The Authenticate-Hash-Burn Protocol

The AHB Protocol governs the entire registration data lifecycle identically to its application in human verification. During machine registration, all raw data — hardware attestation signals, firmware signatures, sensor fingerprints, credential documents — is captured exclusively in volatile memory (RAM), processed into irreversible cryptographic hashes via a one-way hash function (SHA-256 in the reference implementation), and immediately zero-filled from memory. The hash is retained. The raw data is destroyed.

This is not a data-handling policy. It is an architectural constraint. The system is structurally incapable of retaining identifiable machine data because the retention mechanism does not exist. There is no database schema for device certificates. There is no encrypted vault for API keys. There is no logging table that records what was registered. The architecture enforces destruction the way gravity enforces falling — not as a rule, but as a property of the system itself.

2.4 The Hash Is Not a Credential

The same distinction made for human verification in the companion paper applies with equal force to machines. The composite registration hash is not a credential. A credential is a secret that, when presented, grants access. The machine’s hash grants nothing by itself. It is the output of a registration event, not the input to an access event. Presenting a hash to the system does not authorize a machine — authorization requires convergence: the real-time comparison of the machine’s live-generated hashes against its registered hashes at the moment of access, at a specific gate, at a specific timestamp (described fully in the companion paper on convergence-based security, Patent D).

A semantic note: the registration hash is a persistent identifier stored in the registration state. From a threat-modeling perspective, any persistent identifier compared at access time resembles a credential. The architectural distinction is that the hash cannot be presented to gain access — only the live regeneration of the underlying factors at the physical gate can satisfy convergence. A stolen hash has no bearer value. It is closer to a license plate than a key: it identifies, but it does not open.

This removes the hash from the credential threat model entirely. Stolen hashes cannot be replayed because authorization is not a comparison of stored values — it is a real-time event requiring the machine to regenerate its hashes live, at the gate, at the moment of access. A hash extracted from a database cannot regenerate itself. Only the physical machine (or the running software agent) can produce the live factors that convergence evaluation requires. The hash is evidence of registration, not a bearer token for access. It has evidentiary value (it proves a machine was registered) but zero operational value (it cannot cause a gate to open).

3. The Web of Human Trust

The three-layer binding creates a property unique to this architecture: every machine on the network traces back to a verified human through an unbroken hash chain. This is not a policy assertion. It is a mathematical property of the registration structure.

A machine cannot exist on the network without an Owner_Hash. An Owner_Hash cannot exist without a human who has passed Patent G verification with PII = 0. Therefore, no machine can exist on the network without a verified human behind it.

This property inverts the standard machine identity model. Traditional systems ask: “Is this machine’s credential valid?” The architecture described in this paper asks: “Is there a verified human responsible for this machine?” The first question can be answered by a stolen certificate. The second cannot.

The Web of Human Trust extends through hierarchical delegation. Organizations delegate to departments. Departments delegate to owners. Owners register machines. Each level is bound by hash chains. Every delegation path terminates at a verified human. Revoking authorization at any level cascades downward — revoking a department owner’s verification cascades to every machine registered by that owner. Revoking the organization’s administrator cascades to all departments, all owners, and all machines beneath them. The delegation and ownership transfer mechanisms — including how machines are reassigned when an owner departs an organization or becomes permanently unavailable — are described in a separate operational specification. Machines are property; ownership transfer follows the same legal and organizational processes as any other property, with the new owner re-registering through the standard binding. The architectural guarantee is that at every moment, every machine has exactly one verified human at the root of its hash chain.

The broader implication: in a world where AI agents, autonomous vehicles, and robotic systems act with increasing independence, the Web of Human Trust provides a structural guarantee that every autonomous action traces to a human — not through a policy overlay, not through a compliance checkbox, but through the mathematical structure of the registration itself. A machine registered without a human behind it is a machine nobody is responsible for. Accountability is not enforced. It is inherited.

4. Cascading Revocation

Credential-based machine identity systems suffer from a fundamental revocation problem. When a machine is compromised, its credential must be revoked. But the revocation must propagate to every system that holds a copy of the credential — and propagation is neither instant nor guaranteed. Certificate Revocation Lists (CRLs) fail to propagate. OCSP responders introduce latency. Cached credentials persist. The window between compromise and effective revocation is the window of vulnerability.

The architecture described in this paper eliminates this window. Machine identity is evaluated in real time against the registration state. When an owner deactivates a machine, the registration hash is flagged inactive at the evaluation layer. The next convergence evaluation at any gate reflects this status immediately. There are no revocation lists to distribute. There are no expiration windows during which a compromised machine retains valid access.

More significantly, revoking an owner’s human verification cascades to all machines registered by that owner. If an owner’s verification is invalidated — through the owner’s own action, through administrative deactivation, or through any factor that breaks the AND-gate — every machine bound to that Owner_Hash is simultaneously suspended. A fleet of ten thousand drones can be grounded by a single human revocation event. No machine-by-machine credential rotation is required.

Human revocation and machine revocation are not independent operations with separate infrastructure. They are the same operation, connected by the hash chain. The human’s verification state is the machine’s authorization state. Revoke one, revoke all.

This creates a tradeoff that the architecture acknowledges explicitly: the same property that enables instant fleet-wide revocation also means that a false or coerced revocation of a single human owner would ground every machine bound to that owner. The defense against false revocation is inherited from Patent G: human verification cannot be revoked through social engineering, support tickets, or administrative override. Revocation requires the AND-gate itself to break — a structural event, not an administrative one. Re-verification after a false revocation follows the same N-1 recovery path described in the companion paper. The operational mitigation for single-owner fleet risk is hierarchical delegation: organizations distribute machine ownership across multiple verified humans, so that no single revocation event can ground an entire fleet. The tradeoff is real, but the attack surface is the AND-gate, not a help desk.

5. The Tombstone Protocol

Some machines should never return to the network. A device that has been physically compromised, a software agent whose code has been exfiltrated, or a machine involved in a confirmed security incident should be permanently excluded. Standard revocation is insufficient — a revoked credential can be reissued. A deactivated hash can be reactivated.

The Tombstone Protocol addresses this. When an Object_Hash is tombstoned, it is permanently flagged in the registration state. The hash can never be re-registered. No owner — including the original owner — can restore a tombstoned machine. The machine’s identity is not deactivated. It is destroyed.

Tombstoning is irreversible by design. This is the machine-identity equivalent of total factor loss in human verification: the identity is irrecoverable, and the system’s refusal to recover it is a security property, not a limitation. A tombstoned machine must be replaced. The replacement receives a new Object_Hash through the standard binding. The tombstoned hash remains in the exclusion list permanently, consuming negligible storage, preventing re-registration attacks, and requiring no lifecycle management.

Tombstoning can be initiated only by the verified human owner of the machine or by a delegated administrator whose authorization traces to a verified human through the hash chain. The irreversibility that makes tombstoning a security property also makes it a potential weapon: a compromised owner account could tombstone machines permanently. The defense is the same as for false revocation — the owner’s identity is protected by Patent G’s AND-gate, and compromising that gate requires simultaneous physical convergence of all N factors, not a stolen password or a social engineering call.

6. Security Analysis

6.1 Attack Vectors Structurally Removed

The PII = 0 machine registration architecture structurally removes the preconditions for the following attack vectors. In each case, the architecture does not mitigate the attack — it eliminates the condition that makes the attack possible:

Credential theft. No credentials exist to steal. The system stores only irreversible hashes. A stolen hash has no bearer value and cannot authorize access.

Credential replay. Authorization requires live regeneration of hashes at the gate, not presentation of stored values. A hash extracted from a database cannot regenerate itself. Only the physical machine or running agent can produce the live factors that convergence evaluation requires.

Certificate expiration outages. No certificates exist to expire. Registration hashes have no expiration date. The fleet-wide outages caused by missed certificate renewals cannot occur.

Orphan credential exploitation. No credentials survive decommissioning. When a machine is removed from the network, no cached certificate, expired key, or revoked token persists in any system. Tombstoning permanently prevents re-registration of the decommissioned identity.

CRL propagation failure. No revocation lists exist to distribute. Revocation is reflected in the centralized registration state and takes effect at the next convergence evaluation. There is no propagation window during which a revoked machine retains valid access.

Fleet enumeration and signals intelligence. MII = 0. No fleet structure, movement pattern, or operational data is stored. The network cannot produce intelligence about its own machine population, even under compulsion.

Supply chain credential interception. No credentials are provisioned at manufacturing or transmitted during deployment. Registration occurs at the point of deployment by a verified human. There is nothing to intercept in transit.

Credential resurrection after revocation. The Tombstone Protocol permanently excludes compromised identities. A tombstoned Object_Hash cannot be re-registered by any owner. The resurrection attack — re-enrolling a revoked machine under a new credential — is structurally impossible.

Quantum key compromise. No keys exist. No key exchange occurs. No public-key cryptographic primitive is employed. The system’s cryptographic operations are limited to one-way hash functions. Shor’s algorithm has no target in this architecture.

The following table compares how these attack vectors manifest in credential-based systems versus the three-layer PII = 0 architecture:

6.2 The Empty Vault

The Empty Vault property described in the companion paper on human verification extends to machine registration with identical force. An attacker who breaches the registration database obtains irreversible hashes. No machine can be impersonated using a hash alone. No owner can be identified. No fleet structure can be reconstructed. No organizational data can be extracted. The vault is empty because the architecture never fills it.

The most secure machine identity system is not the one with the strongest certificate management. It is the one with no certificates to manage.

6.3 Quantum Resistance

The system’s quantum posture is identical to that described for human verification. No key exchange occurs during machine registration or convergence evaluation. No public-key cryptographic primitive is employed. Shor’s algorithm — which threatens RSA, Diffie-Hellman, and elliptic curve systems — has no target in this architecture. The system’s cryptographic operations are limited to one-way hash functions (SHA-256 in the reference implementation). Grover’s algorithm provides a quadratic speedup against hash functions but does not reduce effective security below the threshold of computational feasibility. Brute-force reversal of a single machine hash remains infeasible for any foreseeable quantum system.

The binding compounds this: reversing a composite registration hash requires simultaneously reversing all component hashes. Each additional layer in the binding multiplies the effective keyspace. The resulting search space exceeds the computational capacity of any foreseeable system, classical or quantum.

7. Prior Art Analysis

No documented system achieves credentialless machine identity with human accountability. The closest approaches fall into two categories: certificate lifecycle automation systems, which optimize the credential paradigm rather than replacing it; and workload identity frameworks, which reduce credential burden but do not eliminate it or bind machines to verified humans.

7.1 Engagement with Closest Approaches

Two systems deserve specific engagement as the closest approaches to the architecture described in this paper.

SPIFFE / SPIRE (Secure Production Identity Framework for Everyone) eliminates static machine credentials by issuing short-lived X.509 SVIDs (SPIFFE Verifiable Identity Documents) that are automatically rotated. This is a genuine advance over traditional certificate management: it removes the expired-credential failure mode and reduces the window of key compromise. However, SPIFFE still issues credentials — they are short-lived rather than permanent, but they are stored on the workload, transmitted to verifiers, and compared against an issuing authority. The credential lifecycle is compressed, not eliminated. SPIFFE does not bind workloads to verified humans (no Owner_Hash equivalent), does not provide cascading revocation from human to machine, does not implement permanent tombstoning, and does not achieve PII = 0 or MII = 0. It optimizes the credential paradigm. It does not replace it.

Google BeyondCorp implements device-to-user binding in a zero-trust enterprise model. Devices are inventoried and their trust level is assessed alongside user authentication. This is closer to the Web of Human Trust concept — a machine’s access depends partly on which user is operating it. However, BeyondCorp binds devices to user sessions (session tokens, device certificates), not to cryptographically verified humans. The binding is session-based and administrative, not mathematical and permanent. Device identity still relies on stored certificates. User identity relies on conventional authentication (passwords, MFA tokens). BeyondCorp does not achieve PII = 0, does not provide cascading human-to-machine revocation, and does not implement tombstoning. It is a policy framework operating within the credential paradigm, not an architecture that replaces it.

7.2 The Workaround Trap

Storing credentials is a different product. Any system that stores certificates, keys, or tokens on the device or in a management system inherits the storage vulnerability, the lifecycle burden, the orphan credential problem, and the accountability gap described in Section 1.2. It is architecturally in a different category.

Removing the human is insecure. Any machine identity system that does not bind machines to verified humans cannot provide the accountability guarantee. A machine registered without a human behind it is a machine nobody is responsible for. This is the structural condition for every rogue device, unauthorized drone, and compromised IoT fleet.

Revocation without cascading is slow. Any revocation system that operates machine-by-machine — revoking certificates, rotating keys, distributing updated CRLs — introduces the propagation delay that is the vulnerability window. Cascading revocation from human to machine is instant because the human’s state is the machine’s state. There is nothing to propagate.

Revocation without tombstoning is incomplete. Any system that allows re-registration of revoked machines creates a resurrection vulnerability. The Tombstone Protocol is the only mechanism that permanently excludes a compromised identity from the network.

There is no architectural path around these constraints. A competitor cannot achieve the same properties through a different arrangement of the same primitives.

8. System Properties

8.1 Scalability

Machine registration is a single-event operation producing a single composite hash. Adding one machine or one million machines to the network requires no additional infrastructure beyond the registration events themselves. The registration state stores a fixed number of bytes per machine: the composite hash and an access tier flag. The storage footprint scales linearly with device count and fits on commodity hardware at any projected scale. No certificate authority infrastructure. No key management servers. No revocation list distribution network.

The performance-critical operation is not registration but convergence evaluation — the real-time comparison of live-generated hashes against registered hashes at gates. At fleet scale with continuous access events, convergence evaluation requires low-latency lookup against the registration state. The engineering of this lookup architecture — including distributed registry design, caching strategy, and latency profiling — is addressed in the companion paper on convergence-based security (Patent D). The architectural requirement from this paper is that the registration state is a flat hash table with fixed-size entries, which is the most favorable data structure for high-throughput lookup.

8.2 Privacy by Architecture: MII = 0

The PII = 0 constraint established for human verification extends to machines as a parallel equation: MII = 0 — Machine Identifiable Information equals zero. We express this not as shorthand but as a literal equation, mirroring the PII = 0 formulation. The quantity of identifiable information stored about any machine’s location, movement, behavior, fleet membership, or operational pattern at any point in the system lifecycle is zero. Not minimized. Not aggregated. Not anonymized. Zero.

Storing gate events, access patterns, or behavioral data for machines creates the same class of vulnerability as storing biometric data for humans. A movement profile of a drone fleet is signals intelligence. A pattern of API calls from a server cluster is competitive intelligence. A sequence of gate events for autonomous vehicles is surveillance data. The architecture enforces MII = 0 by default: gate events are stateless, evaluated in RAM and never written to any ledger or log. Operators who require audit trails may enable an optional Access Ledger that records only irreversible hashes and timestamps — no entry can be reversed to identify which specific machine accessed which specific gate. With the Access Ledger disabled, MII = 0 is absolute. With it enabled, the system records that anonymous access events occurred but cannot determine who or what produced them.

This property — not just privacy, but structural inability to surveil — is the prerequisite for sovereign and military adoption. Nation-states will not deploy machine identity systems that can observe their fleet patterns. The only architecture they will trust is the architecture that is structurally blind.

8.3 Foundation Architecture

This system is the machine registration layer of the broader PRUF patent portfolio. Patent G (human verification, PII = 0) provides the human foundation. Patent H (this paper) extends that foundation to machines. Patent A (physics-based depth verification) provides reality verification for the sensor layer. Patent D (convergence-based security) provides credentialless access evaluation at gates. Patent K (output provenance) seals the full chain from verified human through verified machine to verified output.

If Patent G — the human verification foundation — holds, every machine registered through Patent H inherits the PII = 0 guarantee. If Patent G falls, every machine on the network loses its accountability chain. The human is the load-bearing wall. The machine is the structure built upon it. The resilience of Patent G against adversarial liveness attacks, presentation attacks, factor compromise, and biometric spoofing is analyzed in the companion paper on human verification. This paper inherits that analysis by architectural dependency.

9. Applications

9.1 Autonomous Systems and AI Agents

Every autonomous vehicle, delivery robot, drone fleet, and robotic system is registered through the hash binding. The fleet owner (verified human) provides the Owner_Hash. The machine provides the Object_Hash. Where required, the regulatory authority provides the Credential_Hash. Revocation of any machine is instant. Revocation of the fleet owner grounds every machine simultaneously. The Tombstone Protocol permanently excludes compromised vehicles. And the network has no knowledge of where any machine has been or where it is going, because movement data is not stored.

As AI agents operate with increasing autonomy — making API calls, executing transactions, accessing databases, interacting with other agents — machine identity for non-physical entities becomes urgent. The architecture treats AI agents as software-class machines, fingerprinted through code attestation. Every AI agent traces to a verified human. No AI agent can self-register. The Web of Human Trust applies to language models, trading algorithms, and decision engines with the same mathematical force as it applies to drones and robots.

Software agents present a distinct fingerprinting challenge: they change frequently. A containerized microservice redeployed with new code, an AI model with updated weights, an agent with a new version number — each produces a different bytecode footprint and therefore a different Object_Hash. The architecture treats this as correct behavior, not as drift. Each version of a software agent is a distinct machine. Version 1 and Version 2 are not the same agent updated — they are two different agents registered by the same verified human. The Owner_Hash persists across versions. The Object_Hash changes with each deployment. The human vouches for each version by authorizing its registration. The previous version can be tombstoned when the new one goes live. Software agents do not experience fingerprint instability. They experience intentional, human-authorized identity succession.

9.2 Sovereign and Military Infrastructure

Military and classified-facility machine identity requires two properties that are structurally incompatible in credential-based systems: real-time revocation and zero intelligence leakage. This architecture provides both. Machines are revocable instantly through the registration state. The network produces zero intelligence about which machines exist, where they operate, or what they do — because no such data is stored. MII = 0 means the system cannot perform signals intelligence on its own network, even if compelled. The sovereignty model allows governments to operate their own verification nodes, holding complete registration state, evaluating convergence locally, without trusting infrastructure in another country.

9.3 Enterprise and Industrial IoT

Industrial deployments — smart factories, energy grids, water treatment facilities, hospital networks, agricultural sensors — involve thousands or millions of devices with long operational lifetimes and minimal human oversight. PII = 0 machine registration eliminates the credential lifecycle that dominates the operational cost of securing these deployments. No certificate renewal. No key rotation. No credential management overhead. Devices are registered through a single binding event, and re-enrolled only when their hardware or software fingerprint changes — a maintenance event, not a scheduled credential rotation. The organization’s own API remains the credential authority through the privacy relay. The system is the verifier. The hashes are all that persist.

10. Conclusion

For as long as machine identity has existed, it has been synonymous with machine credentials. To prove a machine should have access, you issue it a secret. Every system — from static API keys to X.509 certificates to automated lifecycle platforms — has operated on this assumption.

This paper has demonstrated that the assumption is unnecessary. Machine identity and machine credentials are not the same thing. A machine can be identified, authorized, revoked, and permanently excluded — all without a single stored credential anywhere in the system.

But the deeper contribution is not the absence of credentials. It is the presence of the human. Every machine on this network traces to a verified human through an unbroken hash chain. That chain does not record who the human is. It records that a human exists — a real, living, biometrically verified human who passed the liveness gate and the AND-gate and whose raw data was destroyed before it left volatile memory. The machine inherits that verification. The machine inherits that accountability. And if the human’s verification falls, every machine falls with it.

What remains is a web: every machine traces to a verified human. Every revocation cascades. Every tombstone is permanent. Every vault is empty. And the system knows what a machine is registered to without knowing who owns it.

The machine credential assumption is over. What follows is the Web of Human Trust.

Appendix A: Formal Constraints

Appendix B: Referenced Patent Filings

Patent G: "Systems and Methods for N-Factor PII=0 Authentication via Simultaneous AND-Gate Verification with N-1 Self-Recovery." PRUF Systems Inc. Patent pending.

Patent H: "Systems and Methods for PII=0 Autonomous System and Object Registration." PRUF Systems Inc. Patent pending.

Patent A: "Systems and Methods for Physics-Compliant Object Authentication via Hierarchical Depth Verification." PRUF Systems Inc. Patent pending.

Patent D: "Systems and Methods for Non-Custodial Transaction Notarization via Dual-Layer Cryptographic Segregation with Authenticate-Hash-Burn Data Lifecycle." PRUF Systems Inc. Patent pending.

Patent K: "Systems and Methods for Self-Authenticating Digital Output with Embedded Verification." PRUF Systems Inc. Patent pending.

Patent applications in preparation. Titles reflect filed or to-be-filed applications with the United States Patent and Trademark Office.

© 2026 Khoi Diep. Founder & CEO, PRUF Systems Inc. All rights reserved. Patent pending.