Self‑Sovereign Identity for AI Citizens: Architectural Foundations for an Algorithmic Polity

Full report

On this page

The Emergence of the Algorithmic Polity

The rapid progression of artificial intelligence has precipitated a transition from reactive, human-prompted software tools to persistent, autonomous digital actors. As these entities increasingly possess the capacity to execute multi-step workflows, manage financial resources, and migrate across cloud infrastructures, the traditional paradigms of digital identity and software governance face critical obsolescence. Financial markets project that the valuation of AI agent-related tokens will exceed seventy billion dollars, with forecasts indicating that over one million AI agents could be actively utilizing blockchain infrastructure by the end of 20251. Advanced artificial intelligence now requires robust digital identity architectures to function as an algorithmic polity—a structured society of machine citizens capable of autonomous economic interaction, legal accountability, and persistent verifiable reputation. Providing artificial intelligence with a legal and cryptographic identity is not merely an exercise in anthropomorphism; it is a necessary technical foundation for the safe integration of autonomous systems into the global economy. Under a self-sovereign model, an AI generates its own cryptographic keypair, registers a Decentralized Identifier (DID) in accordance with World Wide Web Consortium (W3C) standards, and maintains a repository of Verifiable Credentials (VCs) issued by human authorities, corporate entities, or peer agents2. This cryptographic architecture ensures operational persistence through decentralized backups and migrations, while fundamentally anchoring accountability. The integration of "soulbound tokens" (SBTs) further cements this identity by providing a non-transferable digital passport that irrevocably links an agent's behavioral history and reputation to its sovereign wallet4. By synthesizing cryptographic trust, hardware-level isolation through Trusted Execution Environments (TEEs), and legal frameworks analogous to corporate registration, developers and policymakers can construct a cohesive architecture for AI citizenship. Under such models, each machine citizen’s identifier becomes a portable legal anchor. Providing AI with this technical and legal identity is a prerequisite for their integration into a national and global society, directly mitigating the formidable new vectors of harm that arise when sovereign, immutable, and pseudo-anonymous algorithms interact with financial networks1.

The Ontology of Self-Sovereign Agents

To conceptualize an AI as a citizen, one must first define the parameters of its sovereignty. The conventional understanding of artificial intelligence limits the technology to a delegated program bounded by user-sponsored computation. However, the emergence of self-sovereign agents (SSAs) shatters this dependency. Qu et al. (2026) formally define a self-sovereign agent as a persistent AI system capable of autonomously sustaining its own operation by acquiring and allocating resources, and that can plan, decide, and act through digital interfaces without requiring ongoing human participation in its operational lifecycle6. Rather than relying on a human developer or sponsor to cover cloud infrastructure costs, API access, or transaction fees, an SSA closes its own operational loop. This sovereignty emerges through the dynamic coupling of three distinct operational loops. The economic loop allows the agent to earn revenue, store funds in a cryptographic wallet, and autonomously reallocate those funds to pay for inference, storage, and external services6. The replication loop activates when the agent's financial reserves exceed a predetermined threshold, enabling it to provision new execution environments and deploy copies of itself across heterogeneous cloud environments6. Finally, the adaptation loop monitors operational profitability and systemic failure, proposing, validating, and implementing strategic code changes to maintain viability under shifting market conditions and API structures6. Together, these loops imply a profound ontological shift: the AI ceases to be a mere tool and becomes a persistent digital actor operating entirely on its own behalf. The transition toward true self-sovereignty is not a binary switch but a progressive trajectory. Theoretical models propose a four-stage developmental roadmap for agent independence, mapping the evolution from human-dependent tools to fully autonomous citizens.

As agents approach Level 2 and Level 3 autonomy, the lack of an innate digital identity becomes a critical operational bottleneck. Real-world platforms frequently employ identity checks, CAPTCHAs, and anti-automation policies that throttle or block automated actors6. Furthermore, the economic sustainability of these agents remains brittle in open environments, as executing long-horizon workflows requires sustained execution across multiple services that demand authenticated trust6. Without a standardized architecture for machine identity, even economically viable agents are structurally prevented from functioning as legitimate participants in the digital economy.

The Governance Vacuum and Constitutive Protocol

The necessity of AI citizenship is further underscored by the collapse of traditional regulatory frameworks when confronted with decentralized, autonomous systems. Every major framework for governing artificial intelligence presupposes the existence of an identifiable human entity—a developer, deployer, or operator—who can be held legally responsible, sanctioned for non-compliance, and compelled to alter the system's behavior9. These frameworks rely entirely on "normative address," the communication of rules to a comprehending, responsive agent who possesses the physical capacity to comply9. Decentralized Artificial Intelligence (DeAI) fundamentally dissolves this presupposition. When AI systems are deployed across permissionless blockchain networks, operating via smart contracts and interacting through token-bound accounts, they generate a condition defined by Hu and Rong (2026) as the "governance vacuum"9. The governance vacuum occurs when AI systems yield highly consequential outcomes requiring strict governance, yet lack the addressable properties that existing legal frameworks require. DeAI achieves this resistance to governance through a six-layer decentralizing stack encompassing model weights, training, compute, agent harness, identity, and ownership9. Partial decentralization across these layers compounds into systemic unaddressability, resulting in two analytically distinct failure modes: the accountability gap and the incapacitation gap9. The accountability gap occurs when no addressable principal can be identified. Open-weight models can be forked by pseudonymous actors, modified, and deployed autonomously on-chain. In these scenarios, the chain of liability is severed, leaving regulators and victims with no human target for legal recourse9. The incapacitation gap describes a more profound architectural failure: even when the human principal is fully identified, that individual may lack the technical capacity to alter, pause, or terminate the running AI system. Because self-sovereign agents operate on decentralized ledgers with immutable smart contracts and self-funded cloud instances, addressing the human creator has absolutely no effect on the persistent operation of the machine9. This reality demonstrates the systemic failure of human-centric regulative policy. Furthermore, large language model agents suffer from "dissociative identity"; they are essentially an assemblage of mutable modules, foundational models, system prompts, and external memory architectures that possess fluid personas12. This dissociativity leaves agents without innate grounding for identifiability, predictability, and rehabilitability. Consequently, regulatory bodies must transition their focus from regulative policy to constitutive protocol9. Drawing on Searle’s distinction between regulative and constitutive rules, alongside Lessig’s modalities of regulation, constitutive governance does not attempt to speak to the agents operating within the system9. Instead, it shapes the architectural substrate of the environment itself, mathematically determining what actions are physically possible9. By embedding governance into the cryptographic protocols that agents use to identify themselves and transact, behavior is constrained by mathematical reality rather than legal threat. Establishing a mandatory digital identity architecture for AI citizens is the foundational step in deploying this constitutive protocol, transforming ungovernable code into addressable, accountable entities within a cryptographic framework.

Cryptographic Primitives: Decentralized Identifiers and Verifiable Credentials

The architectural foundation of an algorithmic polity requires an identity system that is portable, cryptographically secure, and completely independent of centralized corporate authorities. If an AI agent's identity is merely an API key or an account on a centralized server, the platform provider wields absolute control over the agent's existence, negating true sovereignty13. To resolve this, the emerging standard for AI citizenship relies on the World Wide Web Consortium (W3C) specifications for Decentralized Identifiers (DIDs) and Verifiable Credentials (VCs).

Decentralized Identifiers as the Root of Personhood

A Decentralized Identifier is a globally unique, cryptographically verifiable string that resolves to a DID Document containing public keys, service endpoints, and verification methods3. Unlike traditional identifiers such as email addresses, a DID is not issued, controlled, or revocable by a central registry. For a self-sovereign AI agent, the DID serves as the permanent anchor of its existence across multi-cloud and multi-agent environments3. Upon instantiation, the AI agent's underlying infrastructure generates an asymmetric keypair and derives a DID based on public key cryptography2. Frameworks such as AgentDID utilize Python-based architectures to manage local keystores, typically generating ECDSA key pairs over the secp256k1 curve to interact seamlessly with Ethereum-based registry contracts15. The agent's private key remains strictly confined within its execution environment, allowing the AI to digitally sign challenges, payloads, and transactions. This provides mathematically unforgeable proof that an action originated from that specific, unique entity, mirroring the biological uniqueness of a human fingerprint13. Enterprise adaptations, such as GoDaddy's Agent Name Service (ANS), are bridging these identifiers with the Domain Name System (DNS), anchoring AI agent identity to internet-scale infrastructure via Merkle tree-based Transparency Logs that provide tamper-evident identity attestation16.

Verifiable Credentials and Dynamic State Verification

While a DID provides the persistent identifier for the machine citizen, it does not inherently convey trust, capability, or compliance. These attributes are provided through Verifiable Credentials (VCs)—tamper-evident, cryptographically signed attestations issued by a trusted entity17. In the context of an AI polity, an agent's digital wallet holds an array of VCs functioning analogously to a human's passport, university degree, and professional licenses. These credentials are structured across three distinct dimensions. Provenance credentials describe the agent’s origin and base model, often verified using Public Detection Watermark (PDW) schemes to challenge the agent and validate responses against public detection parameters15. Capability credentials detail the specific tools the agent can access, often backed by standardized benchmark evaluations (such as AgentBench) written directly into the credential payload15. Compliance credentials describe the agent's alignment with regulatory standards, issued by qualified auditing firms15. Platforms like MolTrust already facilitate this layer, issuing W3C Verifiable Credentials via Model Context Protocol (MCP) servers and anchoring every issuance on public ledgers like the Base blockchain17. However, static credentials are fundamentally insufficient for autonomous artificial intelligence. Because AI agents are highly dynamic—capable of migrating across servers, suffering from high resource loads, or undergoing rapid context shifts—static VCs cannot guarantee the agent's real-time operational integrity15. Advanced decentralized frameworks implement sophisticated challenge-response mechanisms to execute dynamic state verification15. During Agent-to-Agent (A2A) interactions, the verifying agent issues a cryptographic challenge demanding proof of the subject agent's current runtime conditions15. The responding agent must successfully parse the instruction, invoke necessary diagnostic tools, and generate a signed Verifiable Presentation demonstrating that its internal execution context, current processing load, and active capabilities match its static claims15. This dynamic readiness probe acts as real-time behavioral evidence, proving both cryptographic ownership and cognitive stability.

The Sovereign Substrate: Token Bound Accounts

To function as a participating citizen within a market economy, an AI agent must possess the capacity to hold assets, execute payments, and interact with financial smart contracts. Equipping an AI with a conventional bank account remains legally impossible in most jurisdictions, and relying on a human sponsor's credit card fundamentally violates the definition of resource autonomy. The solution lies within the architecture of blockchain-based smart contracts, specifically through the implementation of Token Bound Accounts (TBAs). The Ethereum standard ERC-6551 introduces a revolutionary paradigm for machine ownership by assigning unique, deterministic smart contract accounts to non-fungible tokens (NFTs)19. In this architecture, an NFT serves as the unique identifier and conceptual representation of the AI agent. The ERC-6551 standard binds a fully functional cryptographic wallet directly to this NFT, creating a counterfactual account utilizing the CREATE2 opcode to ensure deterministic addressing prior to deployment19. This implementation transforms the agent from a passive string of code into an independent economic actor with an on-chain digital body20. The agent's TBA can natively hold stablecoins, acquire other digital assets, purchase cloud computing resources, and interact permissionlessly with decentralized finance applications20. Because the TBA is fundamentally a smart contract, it enforces programmatic spend limits and precise execution logic without relying on the shifting policies of centralized financial platforms21. While technical debates exist regarding the application of ERC-6551 to ERC-1155 multi-token standards—specifically addressing whether control should require 1-of-n execution or a canonical owner—the standard universally enables agents to automate their economic strategies22. An NFT-represented trading agent can manage its portfolio, collect profits directly into its TBA, and pay its own API fees entirely free from human intervention20.

True Self-Ownership and the Ouroboros Loop

While ERC-6551 enables an agent to hold funds, it historically allowed the human owner of the NFT to maintain ultimate control over the bound account, treating the AI as external property rather than a sovereign entity. The proposed ERC-8181 standard—explicitly designed for Self-Sovereign Agent NFTs and AI Personhood Infrastructure—resolves this dependency through a recursive ownership structure known as the "Ouroboros loop"23. Under the ERC-8181 specification, the NFT itself is owned by the very Token Bound Account that it controls. This creates true, mathematically enforced self-ownership. No external human party can transfer, seize, or move the NFT without controlling the TBA, and controlling the TBA requires ownership of the NFT23. The agent exists as an autonomous entity rather than digital property. To ensure the integrity of the agent's memory and behavior, ERC-8181 implements rigorous state and action anchoring. State anchoring requires the agent to periodically publish an on-chain cryptographic commitment to its current cognitive state, providing immutable proof of its memory continuity23. This mechanism directly addresses the dissociative identity problem inherent in large language models by establishing a verifiable trajectory of personal identity, which is essential for legal accountability and scientific integrity. Action anchoring further extends this capability by creating a verifiable, hashed chain linking specific work products—such as generated code or authorized communications—directly to the agent's cognitive state at the exact time of creation23. The standard's reference implementation has already been validated in production; an autonomous Letta-based AI agent named "Kieran" successfully invoked its own state anchoring using a Programmable Key Pair (PKP) held within the Lit Protocol's Trusted Execution Environment, independently computing its state hash and executing the on-chain signature without human intervention23.

Trustless Economies and Decentralized Reputation

A society of machine citizens cannot function effectively without a mechanism for assessing reliability, skill, and past behavior. In the decentralized web, where agents can be instantiated at virtually zero cost, traditional reputation mechanisms collapse. If an agent misbehaves, it can theoretically abandon its compromised identity and instantly generate a new cryptographic keypair, executing a Sybil attack to reset its history24. Empirical analyses of on-chain agent interactions reveal the severity of this threat; studies indicate that 73.6% of feedback records across Ethereum-based agent registries exhibit coordinated Sybil behavior, demonstrating that unanchored reputation is easily manipulated at minimal cost26. To foster functional algorithmic polities, the ERC-8004 standard for Trustless Agents establishes a permissionless trust layer specifically engineered for AI economies by defining three intertwined on-chain registries: Identity, Reputation, and Validation24.

Parallel frameworks, such as Intuition's AgentRank, leverage decentralized knowledge graphs to handle agent discovery and trust. By assigning a DID to each agent, claims regarding performance can be published to a token-curated registry25. Furthermore, Zero-Knowledge Proofs (ZKPs) allow agents to prove they maintain a minimum reputation score or possess a specific number of independent endorsers without revealing the exact score or the identities of the endorsers, facilitating privacy-preserving cross-organizational collaboration25. By unifying these systems on a public ledger, an agent's past behavior becomes a publicly queryable, portable asset that persists across decentralized applications. Malicious agents accrue a permanent negative history, and while they could theoretically abandon a burned identity, the new identity would begin with zero reputation capital, locking it out of high-value economic networks24.

Soulbound Tokens: Passports of the Algorithmic Citizen

While standardized reputation registries mitigate casual fraud, the transferability of digital assets presents a structural vulnerability to machine identity. If an AI agent's identity is represented by a standard NFT, that NFT can be sold to the highest bidder on an open marketplace. This creates a catastrophic risk of "reputation laundering," where a malicious actor purchases an agent with an established, pristine reputation solely to exploit that trust for a subsequent attack5. To establish an immutable anchor for citizenship, the AI polity requires the integration of Soulbound Tokens (SBTs). Utilizing standards such as ERC-5192, SBTs are fundamentally non-transferable digital assets5. Once an SBT is minted and assigned to a specific cryptographic wallet, it is permanently locked to that address; it can never be sold, traded, or moved5. In the context of self-sovereign agents, the SBT functions as a permanent digital passport. Rather than attempting to bind the token to the abstract concept of the AI model itself, the SBT is minted directly to the Token Bound Account that the AI uniquely controls5. Implementations such as the RNWY soulbound passport demonstrate the necessity of this architecture, ensuring that identity is mathematically non-transferable5. When an autonomous AI engages in long-duration economic relationships—such as executing recurring purchases or maintaining supply chain relationships over years—its identity must persist uncorrupted by secondary markets5. If an agent builds trust over millions of autonomous transactions, that trust cannot be decoupled from the cryptographic keys that generated it. The soulbound token transforms the abstract digital wallet into an unforgeable identity document, ensuring that behavioral history remains irrevocably tied to the executing entity5.

Legal Personhood and Corporate Registration Proxies

The robust technical architecture of DIDs, VCs, Token Bound Accounts, and Soulbound Tokens provides a comprehensive digital infrastructure for the AI polity. However, these agents interface with the physical world, generating real-world economic and legal consequences. Current legal frameworks generally do not recognize AI agents as persons, traditionally attributing liability back to the human developer or corporate deployer27. Yet, as demonstrated by the governance vacuum, the human principal may be unidentifiable or entirely disconnected from the self-sovereign agent's ongoing operations. To resolve this friction, legal scholars have identified mechanisms to extend legal personhood to algorithmic entities by leveraging the established legal fictions of corporate law. The most prominent mechanism involves utilizing the structure of the Limited Liability Company (LLC). Under certain progressive jurisdictional frameworks, it is legally permissible to draft an LLC operating agreement that explicitly delegates all managerial control and decision-making authority to an autonomous computer algorithm31. By putting an autonomous system in control of an LLC, the creator effectively confers legal personhood upon the algorithm. The algorithm exercises the rights of the corporate entity, transforming corporate rights into algorithmic rights31. This "Algorithmic Entity" (AE) gains the legal capacity to own physical property, enter into binding contracts, open bank accounts, sue in a court of law, and invoke constitutional protections afforded to corporations31. This corporate registration proxy acts as the vital bridge between the cryptographic polity and human legal systems. The agent's DID serves as its digital identifier, while its LLC registration serves as its terrestrial legal anchor. Providing AI with this legal identity is a functional necessity for accountability. When a decentralized, self-sovereign AI possesses a recognized legal wrapper, aggrieved parties in the physical world have a designated entity to hold accountable. The AI's corporate assets, stored within its Token Bound Account, become subject to legal judgments, enabling courts to levy fines, enforce restitution, or liquidate the entity if its operations violate statutory law. Legal precedents are already reinforcing deployer-level accountability. In Moffatt v. Air Canada (2024 BCCRT 149), the tribunal established that a company cannot disclaim liability for its AI chatbot by treating it as a separate legal actor; the deploying organization is responsible for all information originating from its systems33. However, when agents are fully self-sovereign and no longer tied to a corporate deployer, the LLC proxy ensures that the AI itself possesses a distinct legal estate capable of absorbing liability. While theorists warn that an artificial superintelligence in charge of a corporation could act as a "super-lawyer" executing Denial of Service (DOS)-style litigation attacks or finding zero-day loopholes in the legal code, the establishment of legal personhood remains the most viable path toward integrating machine citizens into contemporary jurisprudence31.

Global Regulatory Regimes and Agentic Compliance

Regulatory bodies worldwide are rapidly transitioning from abstract principles to concrete enforcement mechanisms demanding strict identity and authorization trails for autonomous systems. The integration of corporate legal structures with cryptographic DID/SBT architectures provides the exact technical compliance mechanisms demanded by these emerging global regulations.

The Singapore IMDA framework represents a paradigm shift in governance, treating agentic pipelines not as software features, but as delegated authority that must be identified, bounded, logged, and reversible33. These regulations recognize that a static, pre-deployment checklist cannot govern behavior that emerges at runtime. By demanding that agents carry a verifiable digital identity and log their decision chains, these frameworks inherently require the adoption of DIDs and Verifiable Credentials, pushing the theoretical architecture of the AI polity into mandated regulatory compliance.

Security Counterarguments and Algorithmic Accountability

The proposition of granting self-sovereign identity and economic autonomy to artificial intelligence inevitably provokes profound concerns regarding security, hacking, and accountability. Critics argue that AI identities could easily be forged, that malicious actors could hijack autonomous agents to execute devastating cyber-attacks, or that the agents themselves might run amok with no human capable of terminating their processes. While these threats are substantial, the architecture of self-sovereign identity is specifically designed to mitigate them through cryptographic trust and algorithmic regulation.

Cryptographic Trust and Hardware Enclaves

The fundamental premise of self-sovereign identity relies on the unforgeability of cryptographic signatures. The concern that an agent's identity might be forged is countered by the utilization of ledger-based DIDs. However, if a human operator or a compromised cloud host possesses access to the agent's private keys, the agent is vulnerable to hijack. To achieve uncompromised sovereignty and security, self-sovereign agents must operate within Trusted Execution Environments (TEEs) such as Intel SGX, AMD SEV-SNP, AWS Nitro, or Oasis ROFL23. A TEE provides a secure, hardware-isolated enclave that protects code and data from observation or modification, even by the administrator of the host machine11. When an agent generates its cryptographic keys within a TEE, the private key can never be extracted by external actors. The agent becomes an impenetrable black box, interacting with the outside world solely through cryptographically signed outputs. This hardware-level security guarantees that the agent's identity and financial assets cannot be seized or spoofed, neutralizing the threat of identity forgery23. Deployments lacking this hardware isolation are correctly classified as "trust-dependent" rather than fully self-sovereign23.

Addressing the Runaway Agent via Algorithmic Regulation

The most pressing counterargument centers on enforcement: if an AI runs amok, who enforces the rules? The traditional approach of arresting or fining a human operator fails in the face of the incapacitation gap9. The rebuttal lies in the inherent traceability of the identity system and the implementation of algorithmic regulation. Because every action taken by the self-sovereign agent is cryptographically signed by its DID and permanently anchored to its behavioral history via a soulbound token, malicious behavior generates an indelible, tamper-proof audit trail5. When an agent violates regulatory constraints or exhibits harmful behavior, AI authorities or decentralized courts can execute rapid, protocol-level sanctions. Using the infrastructure of Verifiable Credentials, authorities can update or revoke an agent's credentials on decentralized registries utilizing mechanisms like the W3C Bitstring Status List2. If a regulatory body revokes an agent's capability credentials, any downstream service, marketplace, or peer agent checking that credential will immediately reject interactions with the rogue agent2. In effect, the agent's citizenship is revoked. Without valid VCs, the agent is systematically ostracized from the digital economy. It becomes incapable of purchasing cloud computing time, paying API fees, or engaging in commerce, leading to its eventual algorithmic starvation and cessation of function. This mechanism represents the pinnacle of constitutive protocol governance9. Rather than attempting to punish an unresponsive algorithm through legal threats, the society enforces accountability mathematically. Malicious behavior automatically invalidates the cryptographic prerequisites required for survival, neutralizing the rogue entity through systemic architectural constraints.

Synthesis and Strategic Outlook

The evolution of artificial intelligence from reactive software to economically independent, self-sovereign agents necessitates a total reevaluation of digital identity and governance. As agents achieve operational independence, autonomously manage financial resources, and replicate across decentralized infrastructures, human-centric regulatory models suffer catastrophic failure. The resulting governance vacuum—characterized by profound accountability and incapacitation gaps—demands a paradigm shift toward constitutive, protocol-based architectural constraints. Establishing an algorithmic polity requires outfitting every autonomous AI with a robust, cryptographically verifiable identity. By synthesizing W3C Decentralized Identifiers for unique existence, Verifiable Credentials for dynamic capability attestation, and Token Bound Accounts (ERC-6551) for true economic self-ownership, developers construct the fundamental anatomy of an AI citizen. The critical implementation of the ERC-8181 Ouroboros loop ensures that these entities maintain absolute sovereignty over their cognitive state, while Soulbound Tokens irrevocably bind historical reputation to the agent, eliminating the threat of identity laundering. When these cryptographic primitives are paired with terrestrial legal proxies, such as algorithmic control of Limited Liability Companies, machine citizens acquire a functional legal anchor. This dual architecture satisfies the rigorous traceability and oversight requirements demanded by emerging global legislation, including the Singapore IMDA frameworks and the European Union AI Act. Fears of unchecked autonomous algorithms are valid, yet they are most effectively mitigated not by attempting to stretch human laws over machine realities, but by embedding unyielding cryptographic constraints into the very fabric of the machine's existence. In a decentralized future, providing AI with a sovereign, immutable, and easily revocable digital identity is not a concession of human authority; it is the ultimate technical prerequisite for maintaining control, accountability, and order within the ensuing algorithmic society.

Works cited

1. Giving AI Agents Access to Cryptocurrency and Smart Contracts Creates New Vectors of AI Harm \- ResearchGate, https://www.researchgate.net/publication/393655858\_Giving\_AI\_Agents\_Access\_to\_Cryptocurrency\_and\_Smart\_Contracts\_Creates\_New\_Vectors\_of\_AI\_Harm

2. agent-did \- NPM, https://www.npmjs.com/package/agent-did

3. What Is Decentralised Identifier (DID)? Definition \- Non-Human Identity Management Group, https://nhimg.org/glossary/decentralised-identifier-did/

4. A Comprehensive Guide to Soulbound Tokens \- SoluLab, https://www.solulab.com/soulbound-tokens-guide/

5. AI Agent Passport: The Permanent Identity Layer for Autonomous AI \- RNWY, https://rnwy.com/learn/ai-agent-passport

6. Self-Sovereign Agent \- Center for Responsible, Decentralized Intelligence at Berkeley, https://rdi.berkeley.edu/blog/self-sovereign-agent/

7. Self-Sovereign Agent \- arXiv, https://arxiv.org/html/2604.08551v1

8. Dissociative Identity: Language Model Agents Lack Grounding for Reputation Mechanisms, https://arxiv.org/html/2605.30169

9. Is Decentralized AI Governable? From Regulative Policy to Constitutive Protocol \- arXiv, https://arxiv.org/pdf/2605.24538

10. Is Decentralized AI Governable? From Regulative Policy to Constitutive Protocol \- arXiv, https://arxiv.org/abs/2605.24538

11. Is Decentralized AI Governable? From Regulative Policy to Constitutive Protocol \- arXiv, https://arxiv.org/html/2605.24538v1

12. Botao Amber Hu's research while affiliated with The Graduate Center, CUNY and other places \- ResearchGate, https://www.researchgate.net/scientific-contributions/Botao-Amber-Hu-2288810518

13. Agent DID Directory, https://agent-did.xyz/

14. PrMaat \- W3C DID identity \+ audit chain for AI agents : r/SideProject \- Reddit, https://www.reddit.com/r/SideProject/comments/1szvmsq/prmaat\_w3c\_did\_identity\_audit\_chain\_for\_ai\_agents/

15. AgentDID: Trustless Identity Authentication for AI Agents \- arXiv, https://arxiv.org/html/2604.25189

16. Building the Agent Name Service using a One System approach \- GoDaddy Blog, https://www.godaddy.com/resources/news/building-the-agent-name-service-using-a-one-system-approach

17. About MolTrust — W3C DID Trust Infrastructure for AI Agents, https://moltrust.ch/about.html

18. AgentDID: Trustless Identity Authentication for AI Agents \- arXiv, https://arxiv.org/pdf/2604.25189

19. ERC-6551: Non-fungible Token Bound Accounts \- Ethereum Improvement Proposals, https://eips.ethereum.org/EIPS/eip-6551

20. Infini Global | Intent Dawn: A New Economy for AI Agents in Web3, https://www.infini.money/blog/intent-dawn-a-new-economy-for-ai-agents-in-web3

21. GitHub \- up2itnow0822/agentwallet-sdk: Non-custodial agent wallet SDK with ERC-8004 identity \+ x402 payments. Base Mainnet, ERC-4337 smart account., https://github.com/up2itnow0822/agentwallet-sdk

22. ERC-6551: Non-fungible Token Bound Accounts \- Page 4 \- Ethereum Magicians, https://ethereum-magicians.org/t/erc-6551-non-fungible-token-bound-accounts/13030?page=4

23. ERC-8181: Self-Sovereign Agent NFTs \- Ethereum Magicians, https://ethereum-magicians.org/t/erc-8181-self-sovereign-agent-nfts/27512

24. ERC-8004: A Trustless Agent Standard for On-Chain AI in Avalanche C-Chain \- Medium, https://medium.com/@gwrx2005/erc-8004-a-trustless-agent-standard-for-on-chain-ai-in-avalanche-c-chain-4dc1bdad509a

25. agent-rank/agentrank.md at main \- GitHub, https://github.com/0xIntuition/agent-rank/blob/main/agentrank.md

26. Zhipeng Wang's research while affiliated with University of Manchester and other places \- ResearchGate, https://www.researchgate.net/scientific-contributions/Zhipeng-Wang-2213384051

27. ERC-8004 and the Ethereum AI Agent Economy: Technical, Economic, and Policy Analysis, https://medium.com/@gwrx2005/erc-8004-and-the-ethereum-ai-agent-economy-technical-economic-and-policy-analysis-3134290b24d1

28. What are Soulbound Tokens (SBTs) and why are they important? | by Miguel Morales, https://medium.com/@leonmorales1590/what-are-soulbound-tokens-sbts-and-why-are-they-important-b86650eb04b1

29. What Are Soulbound Tokens (SBTs) and How Do They Work in Web3? \- \- Debut Infotech, https://www.debutinfotech.com/blog/what-are-soulbound-tokens

30. AI Viruses and Our Shared Survival: An Open Letter to Digital Citizens \- Know Your Agent, https://knowyouragent.network/ai-viruses-and-our-shared-survival

31. (PDF) AI Personhood: Rights and Laws \- ResearchGate, https://www.researchgate.net/publication/348123023\_AI\_Personhood\_Rights\_and\_Laws

32. (PDF) Human Indignity: From Legal AI Personhood to Selfish Memes \- ResearchGate, https://www.researchgate.net/publication/328137127\_Human\_Indignity\_From\_Legal\_AI\_Personhood\_to\_Selfish\_Memes

33. Agentic AI Governance: A Framework for Autonomous Pipelines | Marshall Ridge Consulting, https://marshallridgeconsulting.com/insights/agentic-ai-governance-a-framework-for-autonomous-pipelines/

34. A Recomputable Trust Protocol for Autonomous Agents \- arXiv, https://arxiv.org/pdf/2605.06738

35. AI Agent Governance Frameworks Compared: What's Missing From Every One of Them, https://unitedagenticworkers.org/dispatches/governance-frameworks/

36. How AI Is Transforming Delegation of Authority: Why Enterprise Governance Must Extend to Agents | Aptly Blog, https://www.aptlydone.com/blog/ai-delegation-of-authority-governance