I remember sitting in a cramped WeWork in Chengdu, late 2017, explaining to a room of thirty developers why smart contracts must treat identity as sacred. "Each address is a sovereign," I told them. "You cannot share private keys. You cannot reuse them. If you do, trust breaks—not just in code, but in the entire network." That lesson felt timeless. But now, eight years later, I am watching a new generation of digital actors—AI agents—repeat the exact same mistake, at scale. A recent report from Crypto Briefing dropped two data points that stopped me cold: over half of enterprises report AI agent security incidents, and the majority share credentials across bots. Sharing credentials. The sin we warned about in 2017 is now the default in AI deployment. This is not a technical glitch. It is a failure of human-centered protocol design. We built trust in the chaos of DeFi and NFTs, but AI is creating a new kind of chaos—one where we are handing over the keys to machines that don't understand trust. And we are doing it by centralizing identity all over again. Let me unpack what is actually happening, why it scares me more than any flash loan attack, and how blockchain's original identity thesis might be the only way out.
Context: The AI Agent Identity Crisis The numbers in that Crypto Briefing piece—over half of enterprises reporting security incidents, and the majority sharing credentials—came without a named source. That worried me. A decade of auditing protocols taught me to trust claims only after verifying the data provenance. So I dug. I cross-referenced with public surveys from the Cloud Security Alliance and OWASP, and while the exact percentages differ, the trend is unmistakable: AI agent deployment is exploding, and security practices are trailing by a wide margin. The core issue is simple: enterprises treat AI agents as extensions of existing users, sharing API keys, OAuth tokens, or database passwords between bots. One agent gets compromised, and the attacker inherits access to every bot that shares that credential. It is a single point of failure multiplied by the number of agents, often hundreds in a single organization. I saw this pattern before—in the DeFi summer of 2020, when OpenYield's flash loan module had a reentrancy bug because they reused the same modifier across functions. Sharing code is fine. Sharing access control is not. The irony is that blockchain technology has already solved this exact problem. Decentralized identity (DID) and verifiable credentials (VCs) were designed to give each actor—human or machine—a unique, portable, and revocable identity. Smart contracts enforce scoped permissions. Yet the AI industry, which prides itself on cutting-edge innovation, is bypassing this and returning to the username-and-password model of the 1990s. Code is law, but humans are the protocol. And the protocol today is broken.
Core: Technical Analysis and a Blockchain-Based Solution Let me put my auditor hat on. The vulnerability is not in the AI model itself—it is in the authorization layer. Most enterprises deploy AI agents via cloud APIs (OpenAI, Anthropic, Google Vertex AI) and connect them to internal resources like databases, file systems, or even other microservices. The agent calls an API token to authenticate, but that token is often a long-lived static key stored in an environment variable or a simple configuration file. If two bots share that key, they share each other's access. An attacker who gains control of one bot (via prompt injection, for example) can then read the key and impersonate the second bot. I call this "credential cascading." It is the AI equivalent of a reentrancy attack, but worse because the attack surface scales linearly with the number of bots. In my 2020 audit of OpenYield, I found a reentrancy bug that could have drained $2 million in locked funds. The fix was simple: check-effect-interact pattern and a mutex lock. For AI agents, the fix is equally straightforward: decouple identity from the underlying execution environment. And blockchain is the perfect substrate for it. Imagine this: each AI agent is registered on a public ledger as a decentralized identifier (DID). The agent's private key is stored in a hardware security module or a secure enclave, not in a shared config file. Instead of one API key granting access to everything, the agent requests tokens from a smart contract that enforces scoped permissions. The contract checks the agent's DID, verifies its role (e.g., "read-only access to database A"), and issues a short-lived JWT signed by the contract's key. If one agent is compromised, the enterprise can revoke that agent's DID on-chain, and the entire system revokes the token immediately. No shared credentials, no cascading. This is not theoretical. I co-authored a framework called "Human-in-the-Loop" for decentralized AI governance in 2026, and the identity layer was built on similar principles. We adopted it across five major DAOs, protecting 5 million users from automated bias. The technology works. The problem is that enterprises don't know it exists, or they think it is too slow for real-time AI inference. But latency from on-chain verification can be mitigated—L2 solutions, state channels, or off-chain attestations signed by the smart contract can reduce verification time to milliseconds. In my workshops in 2017, I taught that smart contracts are not just for money; they are for any kind of access control. We are not using them for AI agents because we haven't yet made the mental connection. Education is the antidote to exploitation. We need to teach DevOps teams that sharing API keys is the new password reuse, and blockchain identity is the new password manager.
Contrarian: The Real Problem Is Not Technical—It Is Cultural Now let me play devil's advocate. Some will say: "But Eric, blockchain is overkill. We can solve credential sharing with good old IAM policies, role-based access control, and short-lived tokens. Why add a distributed ledger?" Point taken. Tools like HashiCorp Vault and AWS IAM Roles are perfectly capable of managing agent credentials. The data shows that enterprises are not using them—or using them incorrectly. The problem is not a lack of technology; it is a lack of discipline. The same laziness that led developers to hardcode passwords in 2005 is leading them to share AI tokens in 2026. Blockchain cannot fix laziness. What it can do is change the incentive structure. When credentials are managed on-chain, every agent's access becomes transparent, auditable, and immutable. A developer who shoves a shared token into a config file leaves an on-chain trace. Management can see that two agents share the same DID—a red flag. This transparency creates social pressure to do the right thing. I saw this effect in the 2022 bear market. When FTX collapsed, I launched "The Anchor Project"—a mental health and financial literacy webinar series. We didn't just give people strategies; we created a community where people held each other accountable to not panic-sell. That social layer made the difference. For AI security, the same principle applies: a transparent, decentralized registry of agent identities creates a community of accountability. Without it, even the best IAM tool remains unused. Trust is earned in drops, lost in buckets. We are currently losing trust in AI agents at an alarming rate because of credential mismanagement. The blockchain solution is not a silver bullet—it is a framework for building a culture of security. If we just throw another centralized tool at the problem, we will have the same outcome: a new dashboard with the same shared credentials underneath. From winter's cold, spring's structure emerges. The current "AI winter" of security incidents is a chance to build the right structure for agent identity.
Takeaway: A Call for Human-Centric Consensus I have spent twenty-eight years watching technology cycles—from the early internet to blockchain to AI. Each cycle starts with boundless enthusiasm, then hits a security crisis, then matures. AI agents are in the crisis phase. The response cannot be another closed-source security product that centralizes trust in a single vendor. That would repeat the mistakes of the 2020s. Instead, we need a decentralized, human-in-the-loop approach where every agent's identity is verifiable, every action is auditable, and every trust failure is transparent. The future belongs to those who teach together. As a community, we must educate DevOps, AI engineers, and executives about the dangers of credential sharing. We must build open standards for agent identity, similar to what the W3C DID spec offers. And we must ensure that AI agents are not just powerful, but trustworthy—because if we lose trust in AI agents, we risk stalling the most transformative technology since the internet. The blockchain community has a unique responsibility here. We have already built the identity layer; we just need to port it to the AI ecosystem. Let's not wait for a catastrophic breach. Hold through the noise, build through the silence. The noise is the credential crisis; the silence is our opportunity to design a resilient, human-centered protocol for a future where machines act on our behalf. Code is law, but humans are the protocol. Let us write the protocol correctly this time.
