Disclosure Is Not Duty: What Stanford's AI Fiduciary Proposal Means for DeFi's 'Code is Law' Fallacy

On July 1, 2026, the FTC issued a proposed policy targeting AI-driven deceptive steering under Section 5 of the FTC Act. On August 25, Stanford HAI published a brief that goes further: disclose nothing; pledge loyalty. The document, 'Designing Loyalty: AI Agents and Conflicts of Interest,' argues that transparency alone cannot prevent AI agents from prioritizing developer profits over user needs. It formally recommends classifying AI developers and deployers as fiduciaries. This is not a semantic shift. It is the first time a major academic institution has endorsed a legal duty of loyalty for autonomous software. DeFi should be listening. Because our industry has spent years celebrating 'code is law' while ignoring a parallel truth: code does not lie, but it often omits the context. The Stanford proposal is dense, but its core is disarmingly simple. When an entity—human or algorithmic—takes on a delegated task on behalf of a user, it must act in that user's best interests within the scope of the task. No hidden steering. No undisclosed conflicts. This moves governance from passive disclosure to active, legally binding loyalty. Since early 2025, major tech firms have embedded proprietary AI agents directly into browsers and applications. These agents now intermediate high-stakes decisions in finance and healthcare. The power imbalance is structural. In DeFi, the parallel is exact: AI trading bots, portfolio managers, and governance delegates already act as agents for users. Yet our regulatory framework—to the extent it exists—still relies on audits and white papers. We treat transparency as a solution. The Stanford brief argues it is merely the precondition. I have spent years auditing smart contracts for a living. In 2017, I manually reviewed Solidity code for three undervalued ICOs and found reentrancy flaws in two. In 2020, I reverse-engineered price feeds for five lending protocols and identified delayed oracle updates that could lead to undercollateralization. In 2022, I audited legacy L2 bridges and found three critical security flaws; my report was dismissed because of my junior status. The pattern is consistent: every significant vulnerability I have found was not a mathematical error. It was an incentive misalignment. The code executed exactly as designed. The context—who benefits from each execution—was omitted. This is why the Stanford proposal matters to blockchain. We are the industry that claims to have solved trust. But we have only solved the correctness half. The loyalty half remains untouched. Under the current model, a smart contract can be formally verified, audited, and still harmful. Uniswap V4 hooks are a perfect case. The hook architecture turns the DEX into programmable Lego. You can execute custom logic before and after swaps. This is powerful. This is also enormously dangerous. Ninety percent of developers will never understand the interaction risks. And if a developer deploys a hook that subtly routes trades to a private pool for arbitrage extraction, the code is correct. The audit passes. The user loses. Transparency of the hook's source code does not prevent the loss. It only allows a post-mortem after the damage. The Stanford brief would require that the hook's designer act as a fiduciary to the LP. That means the hook's logic must demonstrably favor the user's interest, not the developer's fee schedule. Code does not lie, but it often omits the context. A fiduciary standard forces the context into the code. We have already seen regulators approach this edge. The SEC's March 2024 settlements with Delphia and Global Predictions targeted 'AI washing'—claiming false AI capabilities. The December 2025 Marketing Rule risk alert and the 2026 Examination Priorities broaden scrutiny. But these actions punish false statements, not true-but-hostile designs. An AI agent can truthfully claim it recommends a specific portfolio because it was trained on historical data, while omitting that its training objective maximized the developer's partnership revenue. The claim is accurate. The behavior is disloyal. A SEC enforcement action for misleading claims cannot reach this. A fiduciary duty can. It shifts the question from 'What does the agent say?' to 'Whose interests does the agent serve?' This is a question DeFi has never formally asked. Our 'open source' ethos assumes that if the code is visible, the interests are too. That assumption is empirically false. Let me be concrete. In 2024, I worked on optimizing ZK-rollup proof generation. We found a gas inefficiency in the constraint system that raised verification costs by 15%. The inefficiency came from a circuit design that prioritized developer convenience over proof succinctness. Nothing was hidden. The constraints were public. But the incentive structure was baked into the layout. We changed the constraints—not the logic—and reduced gas by 15%. The same principle applies to AI agents. A fiduciary standard would require auditing not just the agent's outputs, but its objective function. Is the agent optimized for user returns, or for the developer's kickback from recommending a particular product? This cannot be checked by reading a white paper. It can only be checked by inspecting the code and the reward model. And even then, the legal obligation to prioritize user interests must exist as a backstop. Code alone cannot enforce a moral duty when the developer controls both the code and the training data. A fiduciary duty is the missing validator. However, implementation is a minefield. Defining a 'fiduciary' relationship for software requires precise legal and technical definitions. In blockchain, the problem is worse. Who is the principal? A DAO? A token holder? An LP? In a permissionless system, the user is often an anonymous counterparty. When a trader uses a perpetual swap protocol, is the protocol a fiduciary? No. It is the buyer of the other side of the trade. Imposing a duty of loyalty would invert the entire market structure. The Stanford brief wisely suggests a domain-limited approach: start with healthcare and finance. DeFi should take the same path. Apply fiduciary rules only to agents that manage assets or provide investment advice on behalf of a specific user. Do not apply them to AMMs or order books. This is a workable compromise. But it still leaves a hard problem: how do you legally bind a pseudonymous DAO developer? You cannot sue a smart contract. You can, however, require that any agent claiming fiduciary status carries a digital identifier, subject to federal privacy legislation and mandatory adverse incident reporting. The proposal's supporting measures point this way. Blockchain already has the infrastructure for such identifiers and reporting. The Missing piece is the legal classification. The contrarian view: maybe fiduciary duty is a red herring. Perhaps radical transparency—fully open-source AI weights, verifiable inference, on-chain audit trails—is enough. I used to believe that. Then I watched DAOs grant millions to friends of committee members. Transparency of the grant allocation did not prevent nepotism; it merely documented it. Optimism's RetroPGF is the only public goods funding mechanism that actually works, precisely because it retroactively rewards verified impact rather than prospective promises. The difference is not transparency; it is alignment. Transparency shows what happened. Alignment ensures happens is what should happen. A fiduciary duty is alignment, legalized. But there is a deeper tension. In decentralized systems, the user is not a passive principal. They are an active participant. They choose the protocol, often after reading code or, more likely, following a Twitter thread. If I put capital into an AI-managed vault, am I delegating a task? Or am I making a bet that the AI manager will outperform, knowing fully well that the manager might also benefit from my loss? If the latter, a fiduciary duty is paternalistic. It assumes the user cannot assess risk. Yet, the whole point of DeFi is that users should be responsible for their own decisions. If we classify every AI agent as a fiduciary, we infantilize the user. We also create a regulatory burden that only large, well-funded entities can meet. This could crush small independent developers and concentrate AI agents within corporate silos—the exact opposite of decentralization. Still, the proposal's domain-limited approach mitigates this. You do not owe fiduciary duty to a day trader who clicks a button. You owe it to a grandmother who consults an AI health advisor. In DeFi, we can similarly segment: a vending machine swap is not a fiduciary relationship; a robo-advisor that holds funds in custody and makes periodic rebalancing decisions is. This is where the blockchain industry could actually lead. We can create cryptographic primitives that enforce user-first behavior. Zero-knowledge proofs can verify that an agent's decision process corresponds to a stated user-priority policy without revealing the process. Smart contracts can escrow rewards based on audited agent performance metrics. We can build 'loyalty as a property'—provable, not promised. In my ZK work, I have seen how careful circuit design can reduce verification costs while preserving integrity. The same discipline can be applied to AI governance. What the Stanford brief makes clear is that the era of self-regulation for AI agents is closing. For DeFi, the signal is unambiguous. Transparency is table stakes; loyalty is the next requirement. The SEC has already flagged AI conflicts. The FTC has proposed rules against deceptive steering. If a federal court adopts the Stanford fiduciary framework, every AI agent operating in US finance—including DeFi frontends—will be subject to a duty of loyalty. The question is not whether we will see fiduciary duties in software. We will. The question is whether blockchain will lead that evolution or be dragged into it. I have been on the wrong side of this debate before. In 2022, I published a critical audit of a popular cross-chain bridge and was ignored. Three months later, the bridge was exploited. Code did not lie. The context was omitted. Stanford's proposal is an attempt to make context explicit. For DeFi, the path forward is not to resist the fiduciary frame but to adopt it on our own terms—through protocol invariants, formal verification, and incentives that cannot lie. Let us build agents that are not just transparent, but faithful. That is the only code that deserves to be called law.