<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kwame Bryan on Medium]]></title>
        <description><![CDATA[Stories by Kwame Bryan on Medium]]></description>
        <link>https://medium.com/@kwame.bryan?source=rss-1120c9e4d592------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*eWzFYEkyTDMHVDNjuVc5lg.png</url>
            <title>Stories by Kwame Bryan on Medium</title>
            <link>https://medium.com/@kwame.bryan?source=rss-1120c9e4d592------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 19:35:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kwame.bryan/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[When AI Agents Need to Trust Each Other]]></title>
            <link>https://medium.com/@kwame.bryan/when-ai-agents-need-to-trust-each-other-3ecdc8e7cac7?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ecdc8e7cac7</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[gaming]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 20:21:01 GMT</pubDate>
            <atom:updated>2026-09-28T20:21:01.691Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2sYmSNoQRFlLEHkAl4c5aw.png" /><figcaption>Identity is not trust. Trust is not authority. And that distinction may matter more as software begins acting on our behalf.</figcaption></figure><p>We are rapidly moving toward a world where software does more than answer questions.</p><p>Agents can already browse the web, write code, call APIs, negotiate with services, move assets and coordinate with other agents.</p><p>The interesting problem is no longer simply:</p><p><strong>Can an AI do the task?</strong></p><p>It is increasingly:</p><p><strong>Should this agent be allowed to participate at all?</strong></p><p>Imagine an autonomous marketplace.</p><p>Your agent wants to buy compute from another agent. That agent relies on a pricing agent. The pricing agent relies on a data provider. The data provider may itself be operated by an organisation you have never interacted with.</p><p>Nobody in this chain necessarily knows everyone else.</p><p>Yet decisions still have to be made.</p><p>Who do you trust?</p><p>And perhaps more importantly:</p><p><strong>Why?</strong></p><h3>The Internet Solved Identity Before It Solved Trust</h3><p>Cryptography is quite good at answering questions such as:</p><blockquote><em>Did this account sign this message?</em></blockquote><p>Blockchains make that relatively easy to verify.</p><p>But knowing who signed something does not tell you whether you should trust them.</p><p>Consider these three statements:</p><blockquote><em>This is alice.eth.</em></blockquote><blockquote><em>Alice trusts Bob.</em></blockquote><blockquote><em>Bob is allowed to participate in this transaction.</em></blockquote><p>They sound related.</p><p>They are not the same thing.</p><p>A useful way to think about it is:</p><p><strong>Identity ≠ Trust ≠ Authority</strong></p><p>Identity asks:</p><blockquote><em>Who are you?</em></blockquote><p>Trust asks:</p><blockquote><em>What relationship exists between us?</em></blockquote><p>Authority asks:</p><blockquote><em>What are you actually allowed to do?</em></blockquote><p>As autonomous systems become more capable, keeping those questions separate becomes increasingly important.</p><h3>Trust Is Contextual</h3><p>Human trust is rarely universal.</p><p>You might trust your mechanic to repair your car.</p><p>That does not mean you trust your mechanic to manage your retirement account.</p><p>Software agents need the same distinction.</p><p>Instead of thinking about trust as:</p><p>T(A, B)</p><p>meaning:</p><blockquote><em>Alice trusts Bob.</em></blockquote><p>we need something closer to:</p><p>T(A, B, scope, time) = trust level</p><p>where A is the person or agent expressing trust, B is the subject being trusted, scope is the context, time tells us when the statement applies, and trust level describes the strength of the relationship.</p><p>For example:</p><p>T(alice.eth, bob.eth, GAMING, now) = Full</p><p>should not imply:</p><p>T(alice.eth, bob.eth, FINANCE, now) = Full</p><p>This sounds obvious in human language.</p><p>It becomes much harder when we try to encode it into infrastructure that thousands of programs may eventually depend upon.</p><h3>From Direct Trust to Chains of Trust</h3><p>The next problem is scale.</p><p>You cannot personally evaluate every agent on the internet.</p><p>Neither can your software.</p><p>So trust needs to become composable.</p><p>Suppose:</p><pre>You trust Alice<br>      ↓<br>Alice trusts Bob<br>      ↓<br>Bob trusts Carol</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KsXC4uaGixWT0czMYF5WqQ.gif" /></figure><p>Your system might decide that Carol is sufficiently close to someone you already trust.</p><p>PGP’s web of trust has worked this way for more than twenty-five years. What has changed is that cryptographic identities, smart contracts, and programmable verification now make these relationships machine-readable. ERC-8107 explicitly builds on that web-of-trust idea.</p><p>An agent could present a trust path such as:</p><p>P = (v0, v1, ..., vn)</p><p>where:</p><p>v0 = your root of trust</p><p>and:</p><p>vn = the agent requesting access</p><p>A verifier can then ask whether every relationship along that path satisfies the required rules.</p><h3>A small example</h3><p>One place we have been experimenting with these ideas is <strong>Autonomous Acres</strong>, an agentic sandbox where software agents can act on behalf of players.</p><p>Imagine a player trusting one farming agent to manage crops.</p><p>That agent relies on another agent to trade supplies.</p><p>A third agent provides market information.</p><p>None of these agents needs to trust everyone.</p><p>What matters is whether a valid path leads back to someone the player already trusts.</p><p><em>A trust path is discovered by an indexer, then verified on-chain.</em></p><h3>The Root Matters</h3><p>This detail seems small, but it is fundamental.</p><p>Suppose a system verifies that a chain of trust exists but does not require the chain to begin with someone the verifier actually trusts.</p><p>An attacker can simply create:</p><pre>attacker-one.eth<br>        ↓<br>attacker-two.eth<br>        ↓<br>attacker-three.eth</pre><p>and claim:</p><blockquote><em>Look, I have a valid trust path.</em></blockquote><p>That path means very little unless we constrain its beginning.</p><p>The rule needs to be something like:</p><p>path start = required root</p><p>and:</p><p>path end = required subject</p><p>Trust does not come from the existence of a graph.</p><p>It comes from connection to a root you have chosen to trust.</p><p>That is an important distinction between <strong>reputation</strong> and <strong>trust</strong>.</p><p>A reputation system may tell you that many people think highly of someone.</p><p>A trust system asks whether a relationship matters <strong>to you</strong>.</p><p>ERC-8107’s coordination gates already enforce this: a path must start at the gatekeeper and end at the admitted participant. Making the same guarantee hold for every verification call, not just gated ones, is one of the changes under discussion.</p><h3>Discovery Is Not Verification</h3><p>This may be the most important architectural principle in the entire system.</p><p>Finding a trust relationship and proving one are different jobs.</p><p>An indexer might search millions of relationships and tell your agent:</p><blockquote><em>I found a path from Alice to Carol.</em></blockquote><p>That is useful.</p><p>But you should not trust the indexer simply because it found the answer.</p><p>We can describe discovery as:</p><p>D(graph, requirements) → evidence</p><p>And verification as:</p><p>V(requirements, evidence, canonical state) → true or false</p><p>The security property we actually want is:</p><blockquote><em>If the verifier returns true, then the trust requirements really are satisfied by the underlying state.</em></blockquote><p>And that must hold for <strong>any evidence</strong>, regardless of where it came from.</p><p>That means the discovery service can be wrong.</p><p>It can be outdated.</p><p>It can censor results.</p><p>It can even be malicious.</p><p>At worst, it should prevent you from finding a valid path.</p><p>It should not be able to manufacture one.</p><p>This gives us a useful rule:</p><blockquote><strong><em>Discovery may assist verification. Discovery must never become verification.</em></strong></blockquote><p>That principle applies far beyond blockchain.</p><p>It applies to search engines, retrieval systems, recommendation systems, and agent memory.</p><p>Finding information is not the same thing as establishing that it is true.</p><h3>Names Create Another Problem: People Change</h3><p>Human-readable identities such as ENS names give agents something much better than raw hexadecimal addresses.</p><p>But names introduce an interesting problem.</p><p>Suppose:</p><p>Alice trusts bob.eth</p><p>Bob later sells bob.eth.</p><p>Should the new owner inherit Bob’s trust?</p><p>That is not an obvious yes.</p><p>The trust relationship may have been created because of the person or organisation controlling the name at the time.</p><p>So the system needs to distinguish between:</p><p>the name</p><p>and:</p><p>the controller of the name when trust was established</p><p>One possible approach is to associate trust with a <strong>control epoch</strong>.</p><p>Conceptually:</p><p>ControlEpoch(name, state) = epoch</p><p>When the effective controller of a name changes, its control epoch changes.</p><p>A trust relationship remains valid only while:</p><p>current control epoch = attested control epoch</p><p>This prevents someone from simply purchasing an old trusted identity and automatically inheriting all of its relationships.</p><p>But this is also a major design decision.</p><p>Should trust attach permanently to the name?</p><p>Or should it attach to the controller who held the name when trust was established?</p><p>ERC-8107 currently takes the first position: the ENS name is the identity, and trust survives a transfer. The current specification recommends short expiries to bound that exposure.</p><p>There is a strong argument for reconsidering that.</p><p>Monitoring transfers is advice.</p><p>It is not a guarantee.</p><p>And an on-chain gate cannot simply “watch events” in the human sense.</p><p>This is exactly the kind of issue that needs to be settled before a standard becomes permanent.</p><h3>Revocation Is Harder Than It Looks</h3><p>Trust changes.</p><p>Alice may trust Bob today and revoke that trust tomorrow.</p><p>But signed messages introduce another problem.</p><p>Alice may have previously signed an attestation that has never been submitted.</p><p>Later she revokes Bob.</p><p>Then someone submits the old signed attestation.</p><p>Which one wins?</p><p>A naive implementation can accidentally resurrect trust.</p><p>ERC-8107 currently orders a trustor’s attestations using an increasing nonce and includes explicit nonce invalidation as part of its security model.</p><p>Suppose Alice signs an attestation and gives it to a relayer.</p><p>Later she revokes Bob.</p><p>The relayer still holds the earlier signature.</p><blockquote><strong><em>Smart contracts cannot reason about information they have never seen.</em></strong></blockquote><p>One defence is a nonce floor.</p><p>Alice can raise her minimum valid nonce and invalidate outstanding attestations.</p><p>That works, but it is broad.</p><p>Another possible addition is a submission deadline inside the signed statement:</p><p>current time &lt; validUntil</p><p>Once that deadline passes, the old attestation can no longer be submitted.</p><p>It does not eliminate every problem.</p><p>But it bounds how long an unseen signature remains dangerous.</p><h3>Trust Has a Time Problem Too</h3><p>A registry that checks trust paths on-chain always reads the current state, so it never sees a stale view.</p><p>The problem appears when verification moves elsewhere: proofs generated off-chain, zero-knowledge proofs, or identity that lives on a different chain from the application.</p><p>Imagine:</p><pre>Trust state      → Base<br>ENS ownership    → Ethereum<br>Subregistry      → another L2</pre><p>The verifier may need evidence from several systems.</p><p>So the state being verified becomes something closer to:</p><pre>Canonical State<br>├── Trust state<br>├── ENS control state<br>├── L2 identity state<br>└── Other required state</pre><p>Now freshness becomes part of the security model.</p><p>If an attacker can use very old state, they may prove something that was true before a revocation.</p><p>But requiring extremely fresh state creates the opposite problem.</p><p>The proof may not be available yet.</p><p>So there is a trade-off:</p><p><strong>Smaller freshness window → faster revocation response, worse liveness</strong></p><p><strong>Larger freshness window → better liveness, slower revocation response</strong></p><p>And effective revocation visibility is closer to:</p><pre>revocation visibility<br>=<br>transaction inclusion time<br>+<br>proof availability time<br>+<br>accepted staleness</pre><p>This matters even more when proofs cross chains.</p><p>State roots may need to be published.</p><p>Finality may need to be reached.</p><p>A bridge proof may need to become available.</p><p>Those delays are not merely implementation details.</p><p>They are part of the security model.</p><p>For that reason, I think this machinery belongs in extensions for off-chain proofs rather than in the core standard.</p><h3>Trusting the Verifier</h3><p>Once different verifier contracts can check trust proofs, a zero-knowledge verifier, for example, another uncomfortable question appears.</p><p>What if the verifier itself lies?</p><p>A malicious verifier contract can simply return:</p><p>true</p><p>for everything.</p><p>No trust standard can make arbitrary verifier implementations honest.</p><p>So choosing a verifier is itself a policy decision.</p><p>An application might trust a specific verifier contract, a particular code hash, an audited implementation, a governed implementation, or a verifier approved through some other process.</p><p>That gives us another useful separation:</p><blockquote><strong><em>The standard defines what correct verification means.</em></strong></blockquote><blockquote><strong><em>The application decides which verifier it trusts to perform it.</em></strong></blockquote><p>A standard can define correctness.</p><p>It cannot force trust in an implementation.</p><h3>Why Ethereum Standards Should Be Small</h3><p>This is where standards design becomes interesting.</p><p>It is tempting to solve everything at once:</p><p>identity, trust, reputation, indexing, discovery, privacy, incentives, coordination and proof systems.</p><p>That usually produces an impressive specification.</p><p>It does not necessarily produce a durable standard.</p><p>Standards often work best when they find what engineers call a <strong>narrow waist</strong>.</p><p>The internet is a good example.</p><p>Many applications sit above IP.</p><p>Many physical networks sit below it.</p><p>IP survives because the middle remains relatively small.</p><p>The same philosophy can apply here.</p><p>A trust standard should define the smallest set of semantics necessary for different implementations to agree about what trust means.</p><p>Everything else should be able to evolve.</p><p>The goal is:</p><p>Core = minimum semantics required for secure interoperability</p><p>not:</p><p>Core = every useful feature</p><p>That distinction is harder to maintain than it sounds.</p><p>Because every useful feature has a reasonable argument for inclusion.</p><h3>ERC-8107</h3><p>This is the problem space behind <strong>ERC-8107: ENS Trust Registry for Agent Coordination</strong>, an Ethereum standards-track proposal for ENS-based trust between agents. As of September 2026, it is in <strong>Review</strong>, meaning it is still being peer-reviewed rather than being Final.</p><p>The current proposal already contains substantial machinery for scoped trust, trust levels, signed attestations, nonce invalidation, ENS identity handling, path verification, anchors and ERC-8001 coordination hooks. <a href="https://eips.ethereum.org/EIPS/eip-8107">Ethereum Improvement Proposals</a></p><p>The interesting work now is less about adding mechanisms and more about asking:</p><p><strong>Which ideas are fundamental enough to become permanent?</strong></p><p>Some design decisions in the current specification are deliberate.</p><p>The ENS name is currently treated as the identity across transfers.</p><p>Revocation has its own semantics.</p><p>A per-trustor nonce floor exists.</p><p>Universal scope fallback is supported.</p><p>Public path verification remains part of the core design.</p><p>These are not minor implementation details.</p><p>They state what trust means, and they are still open.</p><p>If you are building agent systems and have a view on any of them, the proposal is explicitly asking for peer review and feedback.</p><p><a href="https://eips.ethereum.org/EIPS/eip-8107?utm_source=chatgpt.com">ERC-8107 specification</a></p><p><a href="https://ethereum-magicians.org/t/erc-8107-ens-trust-registry-for-agent-coordination/27200?utm_source=chatgpt.com">ERC-8107 discussion on Ethereum Magicians</a></p><h3>The Larger Question</h3><p>This problem will not remain confined to Ethereum.</p><p>As agents become more autonomous, every agent ecosystem will eventually face some version of the same questions.</p><p>Who are you?</p><p>Who says you are trustworthy?</p><p>In what context?</p><p>Until when?</p><p>Who do I trust enough to accept their judgement?</p><p>What happens when an identity changes hands?</p><p>What happens when trust is revoked?</p><p>What evidence should my software accept?</p><p>Who gets to decide what counts as proof?</p><p>These sound like blockchain questions today.</p><p>Soon they may simply be internet questions.</p><h3>A Simple Model</h3><p>The architecture I keep coming back to is:</p><pre>Identity<br>   ↓<br>Trust<br>   ↓<br>Policy<br>   ↓<br>Authority<br>   ↓<br>Action</pre><p>Or more simply:</p><p><strong>Identity ≠ Trust ≠ Policy ≠ Authority</strong></p><p>Each layer answers a different question.</p><p>Combining them can make systems easier to build initially.</p><p>Separating them makes systems easier to reason about later.</p><p>And autonomous systems desperately need things we can reason about.</p><h3>Simplicity Is the Hardest Thing to Master</h3><p>One lesson keeps appearing throughout this work.</p><p>The hard part of standards design is rarely inventing another mechanism.</p><p>The hard part is deciding which mechanisms you can remove.</p><p>The goal should not be to make a standard small merely for aesthetic reasons.</p><p>The goal is to make it:</p><p><strong>closed + secure + evolvable</strong></p><p>A good standard should be difficult to simplify further without losing something fundamental.</p><p>That means accepting something uncomfortable.</p><p>Sometimes the most important contribution to a protocol is not another feature.</p><p>It is knowing what <strong>not</strong> to standardise.</p><blockquote><strong><em>Simplicity is the hardest thing to master.</em></strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ecdc8e7cac7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coalition Authority: Containing the Power of Coordinating Autonomous Agents]]></title>
            <link>https://medium.com/@kwame.bryan/coalition-authority-containing-the-power-of-coordinating-autonomous-agents-505556a6ca11?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/505556a6ca11</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Mon, 14 Sep 2026 08:21:02 GMT</pubDate>
            <atom:updated>2026-09-14T08:21:02.014Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BuHMAJsoBWkGcBEVI4hOEw.png" /><figcaption>Why AI safety may depend less on detecting collusion than on controlling what coordinated agents can do</figcaption></figure><p>Vitalik Buterin recently suggested that adversarial governance mechanism design may have an important application in AI safety.</p><p>The connection is compelling. Governance systems have always faced a difficult problem: relatively simple rules must govern participants capable of reasoning about, exploiting, coordinating around, or circumventing those rules. Advanced AI systems may soon face the same problem in a more extreme form, with humans and weaker models governing agents that can reason about institutional rules faster than their principals can revise them.</p><p>That makes one assumption increasingly dangerous: that safety depends on reliably determining whether agents are cooperating, colluding, or simply converging on the same strategy.</p><p>We may not be able to.</p><p>Agents can communicate privately, infer each other’s behaviour, share operators, manufacture new identities, or discover mutually beneficial strategies without ever producing an explicit collusion agreement.</p><p>The more useful security question is therefore:</p><blockquote><strong><em>What authority can a coalition exercise even if we fail to detect that the coalition exists?</em></strong></blockquote><p>This leads to a different way of thinking about AI safety.</p><blockquote><strong><em>Communication does not have to imply authority.</em></strong><em><br></em><strong><em>Coordination does not have to create additional authority.</em></strong><em><br></em><strong><em>Collusion does not have to expand the power available to a coalition.</em></strong></blockquote><p>That is the problem of <strong>coalition authority</strong>.</p><h3>The problem is not coordination itself</h3><p>Coordination is one of the most valuable capabilities autonomous agents can have. Agents can divide work, negotiate resources, manage treasuries, run marketplaces, operate game economies, and execute complex workflows.</p><p>Preventing coordination would destroy much of that value.</p><p>The problem appears when agents combine individually legitimate capabilities into collective power the system never intended any one coalition to possess.</p><p>Buterin described the underlying problem years ago in <em>Coordination, Good and Bad</em>. A company coordinates. So does a cartel. Validators coordinate to maintain a blockchain, but they can also coordinate to attack one.</p><p>The important distinction, then, is not coordination versus non-coordination.</p><p>It is <strong>coordination within intended authority versus coordination that amplifies, redirects, composes, or escapes intended authority</strong>.</p><h3>Safe agents do not necessarily produce a safe institution</h3><p>Most AI safety discussions begin with individual agents. Does the model follow instructions? Does it respect policy? Does it stay within its mandate?</p><p>Those remain important questions, but multi-agent systems introduce another:</p><p><strong>What becomes possible when several individually authorised agents act together?</strong></p><p>Suppose ten agents can each legitimately spend $10,000 per day. The system may have intended these as ten separate operational budgets. If the agents coordinate perfectly, the coalition can exercise $100,000 of synchronised purchasing power.</p><p>Nothing was technically bypassed. Every agent remained within its individual limit.</p><p>The failure is at the coalition level.</p><p>But composition can create danger even when nothing is being summed.</p><p>Suppose Agent A may read a sensitive datastore, while Agent B may send arbitrary messages to an external service. Neither capability is necessarily dangerous alone. Together, however, the agents may create an exfiltration path:</p><p><strong>Read capability + external write capability → data leak</strong></p><p>No spending limit catches this. No aggregate exposure cap needs to be exceeded.</p><p>Coalition risk can therefore arise through both <strong>aggregation</strong> and <strong>capability composition</strong>.</p><p>That is why coalition authority cannot be reduced to ordinary per-agent authorisation.</p><h3>Coordination is a security boundary</h3><p>Security systems already establish boundaries around identities, private keys, accounts, processes, networks and capabilities. Multi-agent systems may also need boundaries around <strong>collective authority</strong>.</p><p>Suppose several agents jointly produce an action. We may know that every signature is valid, every participant stayed within policy, and the final transaction executed exactly as specified.</p><p>Those facts still do not answer:</p><p><strong>Should this group have been able to exercise that authority together?</strong></p><p>This gives us three distinct concepts:</p><p><strong>Correctness</strong> — Was the action performed correctly?</p><p><strong>Authority</strong> — Was the action permitted?</p><p><strong>Coordination safety</strong> — Was this coalition permitted to exercise that authority collectively?</p><blockquote><strong><em>Correctness ≠ Authority ≠ Coordination Safety</em></strong></blockquote><p>A correct proof of an unauthorised action remains unauthorised. And individually authorised actions can still compose into a collectively dangerous outcome.</p><h3>Detection is the wrong place to put all of our trust</h3><p>It would be convenient if harmful coordination could simply be detected. But that is a fragile foundation.</p><p>Two agents may communicate directly, infer each other’s behaviour through repeated interaction, share a controller, or independently discover the same profitable strategy. A single actor can also instantiate multiple agents that appear unrelated.</p><p>So rather than assume:</p><p><strong>If harmful collusion occurs, we will detect it,</strong></p><p>a safer architecture assumes:</p><p><strong>Some harmful coordination will go undetected.</strong></p><p>That changes the engineering problem. Instead of asking how to prevent agents from communicating, we ask what they can actually do once they communicate successfully.</p><p>This is much closer to traditional security engineering.</p><h3>Communication should not manufacture authority</h3><p>Suppose Agents A, B and C secretly coordinate. Maybe we detect it. Maybe we do not.</p><p>Their communication itself should not grant them control over protected resources.</p><p>This resembles capability security. Two processes may exchange unlimited messages, but that does not automatically give either process a capability it did not already possess.</p><p>Autonomous agents should be treated similarly.</p><p>They may reason together. They may negotiate. They may even conspire.</p><p>But:</p><blockquote><strong><em>Communication(C) should not imply Authority(C).</em></strong></blockquote><p>And ideally:</p><blockquote><strong><em>Collusion(C) should not imply AdditionalAuthority(C).</em></strong></blockquote><p>That moves the hard problem from the unknowable internal state of the agents to a smaller boundary: the place where authority becomes executable.</p><h3>The real achievement is localisation</h3><p>Suppose all state-changing access to a protected resource passes through a gateway, and that gateway correctly enforces authority, policy and exposure limits.</p><p>Then a coalition cannot exercise more protected authority through that gateway than the gateway permits.</p><p>This is almost tautological.</p><p>The value is not that we have solved collusion. The value is that we have <strong>localised the hard problem to a smaller trusted computing base</strong>.</p><p>Instead of trusting every agent, every communication channel and every coalition, we concentrate trust in a narrower enforcement boundary.</p><p>That is still meaningful. Security engineering repeatedly works by shrinking the number of components we must trust.</p><p>The gateway becomes the place where we must be right.</p><p>Everything outside it can be treated more adversarially.</p><h3>Why this is not just ordinary access control</h3><p>At first glance, coalition authority can sound like familiar risk management: aggregate limits, concentration caps, counterparty restrictions and transaction monitoring already exist in banking and trading systems.</p><p>The difference is not that these controls are new.</p><p>The difference is the <strong>rate and cost structure of autonomous agents</strong>.</p><p>Human-centred controls are usually designed for human operators probing policy boundaries at human speed. Autonomous agents can search policy space continuously, coordinate across thousands of interactions, enumerate allowed destinations, discover combinations of capabilities, and exploit edge cases faster than the humans maintaining those rules can patch them.</p><p>At the same time, the cost of creating apparently independent participants may fall close to zero.</p><p>That changes the threat model.</p><p>An allowlist maintained at human speed may be explored at machine speed. A separation-of-duties rule weakens when “independent” identities can be manufactured cheaply. A rule set becomes a search surface when agents can repeatedly test where its boundary actually lies.</p><p>This leads to an important design distinction.</p><h3>Enumerative constraints</h3><p>These describe permitted and prohibited cases:</p><ul><li>allowlists</li><li>denylists</li><li>forbidden combinations</li><li>counterparty tables</li><li>hand-written policy rules</li><li>manually curated exceptions</li></ul><p>They are useful, but they age. Every enumerative rule creates a search problem for the agents and a maintenance problem for the humans.</p><h3>Structural constraints</h3><p>These remove the capability itself:</p><ul><li>the treasury contract owns the assets</li><li>the agent never receives the private key</li><li>all privileged calls must cross a gateway</li><li>a hard limit cannot be raised without delay</li><li>irreversible exit requires a different custody path</li><li>one capability cannot invoke another directly</li></ul><p>These constraints degrade much more slowly because there is less policy surface to probe.</p><p>No clever edge case reveals a private key the agent was never given.</p><p>This suggests a practical design heuristic:</p><blockquote><strong><em>Prefer structural containment wherever possible. Treat enumerative policy as a component with a shelf life.</em></strong></blockquote><p>Enumerative controls still matter. They provide flexibility and context that structural constraints cannot.</p><p>But they should sit inside a structural boundary that remains meaningful when the policy is incomplete.</p><p>This also explains why complete mediation matters.</p><p><strong>Structural containment is what makes enumerative policy worth maintaining.</strong></p><h3>Authority is a flow problem</h3><p>Authority has a magnitude, but it also has a destination.</p><p>A coalition authorised to move $50,000 internally is not necessarily equivalent to one authorised to move $50,000 into an external account it controls.</p><p>So the security question is not only:</p><p><strong>How much authority can the coalition exercise?</strong></p><p>It is also:</p><p><strong>Where can that authority flow, and what happens once it gets there?</strong></p><p>A useful model is:</p><p><strong>Source → Authority Boundary → Action → Destination</strong></p><p>Three properties matter especially.</p><h3>Destination</h3><p>Does the action remain inside the governed environment, or move power to an external system?</p><h3>Reversibility</h3><p>Can the action be cancelled, frozen or recovered?</p><h3>Observability</h3><p>Does the system retain enough visibility to apply future policy, or does the action disappear into an opaque domain?</p><p>The most dangerous case is <strong>authority escape</strong>: power shifts from a governed capability to something outside the original control domain.</p><p>A game agent may turn internal credits into an external asset. A marketplace agent may convert a bounded purchasing capability into an unrestricted credential. A treasury agent may move assets to an address outside the system’s ability to freeze or recover them.</p><p>At that point, containment has failed even if the initial action was technically within limits.</p><p>There is a trap here, however.</p><p>If the system attempts to ask:</p><p><strong>Is this external destination secretly controlled by the coalition?</strong></p><p>we have reintroduced the very detection problem we were trying not to depend upon.</p><p>A coalition-controlled address may look exactly like an ordinary counterparty.</p><p>The safer pattern is therefore structural:</p><blockquote><strong><em>Do not require the system to know who secretly controls every destination. Restrict which classes of destinations are reachable in the first place.</em></strong></blockquote><p>That may mean default-denying external destinations, requiring elevated approval for unrecognised exits, using predefined settlement routes, or separating reversible internal transfers from irreversible external ones at the custody layer.</p><p>This does create tension with the limitations of allowlists: any enumerated list can be probed and may become stale.</p><p>The resolution is the same structural/enumerative distinction.</p><p>An allowlist should not be the final security boundary.</p><p>The structural boundary is that <strong>unrecognised destinations cannot receive irreversible authority without crossing a stronger approval path</strong>.</p><p>The list may change.</p><p>The escalation invariant should not.</p><h3>The bypass problem</h3><p>The whole model depends on complete mediation.</p><p>Suppose a treasury is supposedly controlled by:</p><p><strong>Agents → Policy → Gateway → Treasury</strong></p><p>But an agent also holds a raw signing key that can move treasury assets directly.</p><p>Then the real architecture is simply:</p><p><strong>Agent → Treasury</strong></p><p>The gateway is decoration.</p><p>Every protected operation must therefore cross the boundary being analysed.</p><p>For a smart-contract treasury, the contract itself may need to own the assets and expose only mediated operations. For an API system, privileged credentials may need to remain inside an enforcement service rather than inside the agent runtime. For a game economy, agents should not receive administrative capabilities capable of bypassing the game’s economic rules.</p><p>This is partly cryptographic, but it is also about custody, system architecture and economics.</p><p>The question is not merely:</p><p><strong>Is the gateway secure?</strong></p><p>It is:</p><blockquote><strong><em>Is the gateway actually the gateway?</em></strong></blockquote><h3>Where ERC-8001 fits</h3><p>ERC-8001 provides one way to make declared multi-party coordination explicit.</p><p>Its core lifecycle is deliberately small:</p><p><strong>Propose → Accept → Ready → Execute</strong></p><p>An agent proposes an intent. The participant set is explicit. Participants accept the same coordination object, and those acceptances are cryptographically bound to it.</p><p>The standard does not determine whether the coalition is safe.</p><p>That is a feature, not a flaw.</p><p>Its value is that it gives the system a concrete answer to:</p><p><strong>Who is attempting to act together, and what exactly did they agree to?</strong></p><p>A policy layer can then ask whether those participants should exercise this authority together.</p><p>An execution layer can ask how much authority should actually flow through the resulting action.</p><p>These are separate responsibilities.</p><h3>ERC-8001 is not required for the idea</h3><p>Coalition authority should not depend conceptually on one standard.</p><p>A multisig transaction is also a coordination object. So is a DAO proposal, an enterprise approval workflow, or an orchestration plan produced by an agent system.</p><p>The general structure is:</p><p><strong>Coordination Object → Authority Policy → Execution Boundary → Destination</strong></p><p>ERC-8001 is useful because it standardises the coordination object for autonomous agents.</p><p>But the security model is broader.</p><p>That matters because otherwise coalition authority would merely be an argument for ERC-8001 rather than a general architectural principle.</p><h3>Identity is not independence</h3><p>Coalition policy immediately encounters a difficult identity problem.</p><p>Suppose a rule requires three independent agents, and the system receives approvals from three separate identities.</p><p>Are they independent?</p><p>Not necessarily.</p><p>One operator may control all three.</p><p>Different identities do not imply different controllers.</p><p>ERC-8107 can contribute persistent identity and trust information, but identity is not the same thing as proof of independent control.</p><p>A serious coalition-authority system may need attestations such as:</p><p><strong>These participants do not share a controller.</strong></p><p>Or:</p><p><strong>This reviewer is institutionally independent from this executor.</strong></p><p>Those claims may eventually depend on organisational attestations, hardware evidence, decentralised trust, zero-knowledge credentials, legal identity systems, or mechanisms we have not yet designed.</p><p>This should remain an open problem rather than something we pretend identity alone solves.</p><h3>Policy remains the hard frontier</h3><p>Even with perfect mediation, the problem is not eliminated.</p><p>It is moved.</p><p>The policy layer still has to answer:</p><p><strong>Should these agents exercise this authority together?</strong></p><p>That judgment may be wrong. The policy may be incomplete, stale, manipulated, poorly calibrated, or internally inconsistent. A sophisticated coalition may satisfy every written rule while violating the intention behind them.</p><p>This is another reason structural constraints matter.</p><p>Enumerative policy degrades under exploration. Structural containment defines what remains impossible even when the policy has gaps.</p><p>Containment therefore moves the frontier from unconstrained agent behaviour into an explicit policy and enforcement boundary.</p><p>That is an improvement because policy can be inspected, tested, revised and audited.</p><p>But it is not omniscience.</p><p>Residual risk remains.</p><h3>Enforcement is also an attack surface</h3><p>The mechanisms we add to contain coalitions become powerful actors themselves.</p><p>A critic that can suspend execution has authority.</p><p>A guardian that can prohibit exit has authority.</p><p>A veto mechanism has authority.</p><p>A recovery system has authority.</p><p>Those components can therefore be captured, manipulated or abused.</p><p>A critic may collude with the coalition it reviews. A guardian may become a censorship point. A veto mechanism may freeze legitimate activity. A recovery path may become the easiest route for attackers to seize control.</p><p>So the enforcement layer must be analysed under the same adversarial assumptions as the agents it governs.</p><p>That may require:</p><ul><li>threshold guardians instead of a single guardian</li><li>separation between monitoring and intervention</li><li>bounded veto periods</li><li>auditable reasons for suspension</li><li>appeal or override paths</li><li>independent recovery mechanisms</li><li>hard limits on the authority of the enforcement system itself</li></ul><p>The broader lesson is uncomfortable but important:</p><blockquote><strong><em>Every mechanism that can constrain agents can itself become a source of concentrated authority.</em></strong></blockquote><p>Coalition safety therefore applies to the defenders too.</p><h3>Counter-coordination</h3><p>A robust system should permit coordination against harmful coalitions.</p><p>If one group begins behaving destructively, others may need to organise a response. In autonomous systems, this might involve guardians, challenge periods, revocation, principal override, temporary suspension, or emergency capability reduction.</p><p>But counter-coordination must itself be bounded.</p><p>Otherwise, the mechanism designed to stop one coalition simply creates another coalition with greater power.</p><p>The goal is not maximal defensive authority.</p><p>It is <strong>structured counter-authority with limited scope and clear failure modes</strong>.</p><h3>A broader safety stack</h3><p>This suggests a layered architecture:</p><p><strong>Model behaviour</strong><br>What does the agent want to do?</p><p><strong>Policy</strong><br>What behaviour is admissible?</p><p><strong>Authority</strong><br>On whose behalf may it act?</p><p><strong>Coordination</strong><br>Who is attempting to act together?</p><p><strong>Coalition authority</strong><br>What aggregate or composed capability may this group exercise?</p><p><strong>Authority flow</strong><br>Where may that capability go?</p><p><strong>Execution containment</strong><br>How much irreversible damage remains possible?</p><p><strong>Verification</strong><br>What actually happened?</p><p><strong>Recovery</strong><br>Can the action be reversed or countered?</p><p>Each layer answers a different question.</p><blockquote><strong><em>Correct execution does not prove authority.</em></strong><em><br></em><strong><em>Individual authority does not imply safe coalition authority.</em></strong><em><br></em><strong><em>Valid coalition authority does not imply every destination is safe.</em></strong><em><br></em><strong><em>And defensive authority is not safe merely because it belongs to the defender.</em></strong></blockquote><h3>From adversarial coordination to coalition authority</h3><p>“Adversarial coordination” is a useful threat model.</p><p>We assume agents may coordinate strategically, collude, deceive, share operators, create identities cheaply, discover capability compositions, and understand the mechanism better than the humans governing them.</p><p><strong>Coalition authority</strong> is the corresponding defensive question:</p><blockquote><strong><em>What power does the system make available to agents acting together, and where can that power flow?</em></strong></blockquote><p>That question remains meaningful even if collusion detection fails completely.</p><p>That is precisely why it is useful.</p><h3>The connection back to governance</h3><p>Governance has spent centuries dealing with strategically capable actors: companies, voters, bureaucracies, courts, markets, cartels and coalitions.</p><p>The response has rarely been to align every actor perfectly.</p><p>Instead, societies build institutions: checks and balances, budgets, vetoes, audits, separation of powers, courts and exit rights.</p><p>These mechanisms shape what coalitions can do and where their authority ends.</p><p>Future AI governance may require the same transition.</p><p>A sufficiently capable autonomous agent does not stop being a strategic actor because it is software. Once many such actors can coordinate at machine speed, AI safety becomes an institutional design problem, at least partly.</p><h3>The principle</h3><p>The resulting principle is simple:</p><blockquote><strong><em>We may never reliably know whether autonomous agents are colluding.</em></strong></blockquote><blockquote><strong><em>Fortunately, knowing is not always necessary.</em></strong></blockquote><blockquote><strong><em>Communication does not have to imply authority.</em></strong></blockquote><blockquote><strong><em>Individual capabilities do not have to compose into unintended coalition capabilities.</em></strong></blockquote><blockquote><strong><em>Bounded authority does not have to be allowed to escape into an ungoverned environment.</em></strong></blockquote><blockquote><strong><em>Structural constraints should carry the guarantees that enumerative policy cannot maintain indefinitely.</em></strong></blockquote><blockquote><strong><em>And the systems enforcing those constraints must themselves be treated as potential sources of concentrated power.</em></strong></blockquote><p>The objective is not to eliminate coordination.</p><p>It is to contain the authority coordination can exercise, constrain how capabilities compose, control where authority can flow, and ensure that the mechanisms enforcing those constraints do not become the next unchecked coalition.</p><p>ERC-8001 can make declared coordination explicit.</p><p>ERC-8107 and related systems can contribute identity and trust.</p><p>Policy can constrain coalition authority.</p><p>Execution gateways can mediate capability.</p><p>Guardians can provide counter-coordination.</p><p>Structural controls can ensure that important capabilities are never granted in the first place.</p><p>But none of these pieces solves the problem alone.</p><p>The broader shift is what matters.</p><p>Instead of asking only:</p><p><strong>Can we trust these agents?</strong></p><p>we should increasingly ask:</p><blockquote><strong><em>What can these agents do together if we cannot and which capabilities remain impossible no matter how cleverly they coordinate?</em></strong></blockquote><p>That may become one of the defining security questions of autonomous AI.</p><h3>Further Reading</h3><p>Vitalik Buterin — <em>Coordination, Good and Bad</em><br><a href="https://vitalik.eth.limo/general/2020/09/11/coordination.html">https://vitalik.eth.limo/general/2020/09/11/coordination.html</a></p><p>Eric Drexler — <em>Preventing AI Collusion: Are You Paying Attention Now?</em><br><a href="https://aiprospects.substack.com/p/preventing-ai-collusion-are-you-paying">https://aiprospects.substack.com/p/preventing-ai-collusion-are-you-paying</a></p><p>ERC-8001 — Agent Coordination Framework<br><a href="https://eips.ethereum.org/EIPS/eip-8001">https://eips.ethereum.org/EIPS/eip-8001</a></p><p>ERC-8107 — ENS Trust Registry<br><a href="https://eips.ethereum.org/EIPS/eip-8107">https://eips.ethereum.org/EIPS/eip-8107</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=505556a6ca11" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Autonomous Agents Can Learn from Video Game Development and Where ERC-8001 Fits.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@kwame.bryan/what-autonomous-agents-can-learn-from-video-game-development-and-where-erc-8001-fits-9f9174d81d83?source=rss-1120c9e4d592------2"><img src="https://cdn-images-1.medium.com/max/1448/1*cQO10c84CtdCfSx6ATdHmQ.png" width="1448"></a></p><p class="medium-feed-snippet">What autonomous agents can learn from high-performance game AI</p><p class="medium-feed-link"><a href="https://medium.com/@kwame.bryan/what-autonomous-agents-can-learn-from-video-game-development-and-where-erc-8001-fits-9f9174d81d83?source=rss-1120c9e4d592------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@kwame.bryan/what-autonomous-agents-can-learn-from-video-game-development-and-where-erc-8001-fits-9f9174d81d83?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/9f9174d81d83</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[game-development]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Sun, 12 Jul 2026 20:21:00 GMT</pubDate>
            <atom:updated>2026-07-12T20:21:00.758Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Verifiable Agent Harness: The Missing Layer in Agentic Engineering]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/@kwame.bryan/the-verifiable-agent-harness-the-missing-layer-in-agentic-engineering-b2a0e5cdf1fb?source=rss-1120c9e4d592------2"><img src="https://cdn-images-1.medium.com/max/2600/1*tBFfKoO-R-GvclVpJE2h5Q.png" width="3434"></a></p><p class="medium-feed-snippet">Software engineering is moving through a major interface change.</p><p class="medium-feed-link"><a href="https://medium.com/@kwame.bryan/the-verifiable-agent-harness-the-missing-layer-in-agentic-engineering-b2a0e5cdf1fb?source=rss-1120c9e4d592------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@kwame.bryan/the-verifiable-agent-harness-the-missing-layer-in-agentic-engineering-b2a0e5cdf1fb?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2a0e5cdf1fb</guid>
            <category><![CDATA[agentic-engineering]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 20:21:01 GMT</pubDate>
            <atom:updated>2026-06-29T20:21:01.114Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Invisible Complexity of a “Simple” Transaction]]></title>
            <link>https://medium.com/@kwame.bryan/the-invisible-complexity-of-a-simple-transaction-aed4e99db20a?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/aed4e99db20a</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[erc8001]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Tue, 07 Apr 2026 17:06:01 GMT</pubDate>
            <atom:updated>2026-04-07T17:06:01.295Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FqpjAZ4gCN6mm_DfagEe4w.png" /><figcaption>The Invisible Complexity of a “Simple” Transaction</figcaption></figure><h3>Part One: Maya Approves a Transaction</h3><p>Maya wants to repay a 500 DAI debt to a lending protocol. She opens her wallet, sees a transaction request, and clicks “Confirm.”</p><p>What she thinks happened: <strong>“I repaid my loan.”</strong></p><p>What actually happened requires twelve paragraphs to explain.</p><h3>The Execution Path Maya Never Saw</h3><p>The lending protocol Maya has recently been upgraded to an ERC-7702-compatible architecture. This means the address receiving her repayment — an address that used to be a passive EOA — can now execute arbitrary logic.</p><p>When Maya’s repayment lands, the recipient address triggers a callback. That callback invokes a solver contract. The solver checks whether Maya has any outstanding positions elsewhere. It finds a deprecated lending position she forgot about three years ago. It initiates a partial liquidation of that position to “optimise her portfolio.” The liquidation triggers a DEX swap. The swap routes through a liquidity pool that Maya herself provided liquidity to six months ago. Because she’s now both the swapper and the liquidity provider, she pays fees to herself — minus the protocol’s take.</p><p>Meanwhile, the original lending protocol emits an event. An off-chain agent monitoring that event interprets it as a signal to rebalance Maya’s collateral ratio. The agent initiates a separate transaction from Maya’s account (she previously authorised “automated optimisation” without fully reading the terms). That transaction touches three more protocols.</p><p>Maya’s “simple repayment” has now touched seven contracts, triggered two agent-initiated follow-on transactions, and created a cascade of state changes across five protocols.</p><p>Her wallet displayed: <strong>“Repay 500 DAI to LendingProtocol.”</strong></p><p>She got: a financial Rube Goldberg machine she never agreed to.</p><h3>The Trust Assumptions She Didn’t Know She Made</h3><p>Maya’s experience reveals a stack of implicit trust assumptions:</p><p><strong>Assumption 1: The recipient address is passive.</strong><br>She assumed that sending funds to an address means the address will receive them. She didn’t account for the possibility that the address might <em>do things</em> upon receipt.</p><p><strong>Assumption 2: The transaction description is complete.</strong><br>Her wallet inferred meaning from calldata decoding. It showed her what function was being called. It couldn’t show her what that function would <em>cause</em> — the downstream effects, the callbacks, the agent-triggered automations.</p><p><strong>Assumption 3: The protocol boundaries are clear.</strong><br>She thought she was interacting with one lending protocol. Her transaction activated logic across an interconnected web of positions, agents, and contracts she didn’t know existed.</p><p><strong>Assumption 4: Her past consents were informed.</strong><br>She authorised an agent to “optimise” her positions months ago. She didn’t understand what that meant. She still doesn’t.</p><p>Each of these assumptions was reasonable in an older Ethereum. They’re increasingly dangerous now.</p><h3>Part Two: The Agentic Coordination Problem</h3><p>Maya isn’t acting alone anymore.</p><p>She has authorised three agents to operate on her behalf:</p><ol><li><strong>RebalanceAgent</strong> — maintains her collateral ratios</li><li><strong>YieldOptimizer</strong> — moves idle assets between lending protocols</li><li><strong>PaymentSettler</strong> — handles recurring obligations</li></ol><p>Each agent has its own model of Maya’s intent. RebalanceAgent thinks Maya wants safety above all else. YieldOptimizer thinks she wants maximum yield. PaymentSettler thinks she prioritises timely settlement over cost.</p><p>These agents don’t coordinate. They issue transactions independently, based on their narrow view of Maya’s preferences.</p><p><strong>A Tuesday Morning:</strong></p><p>At 9:00 AM, RebalanceAgent initiates a collateral swap to reduce Maya’s risk exposure. It moves 2 ETH into a “safer” protocol.</p><p>At 9:03 AM, YieldOptimizer detects the new deposit and initiates a yield strategy that involves staking ETH on a bridge.</p><p>At 9:15 AM, PaymentSettler needs to settle a 100 USDC obligation. It looks for Maya’s most liquid assets. It finds the ETH that RebalanceAgent just moved — and is now being bridged by YieldOptimizer. PaymentSettler attempts to liquidate that position.</p><p>The result: conflicting transactions, failed settlements, and Maya’s collateral locked in a bridge she didn’t know existed.</p><p>Maya authorised three agents to help her. She got three agents fighting over her assets.</p><h3>The Trust Assumptions Hidden in Agent Authorisation</h3><p><strong>Assumption 5: Agents share context.</strong><br>Maya assumed that if she authorised multiple agents, they would coordinate. They don’t. They operate in silos, each optimising for its own objective function.</p><p><strong>Assumption 6: Agent scopes are bounded.</strong><br>Maya assumed each agent’s authority was limited to its stated purpose. But in a world where execution paths are dynamic, “purpose” becomes fuzzy. YieldOptimizer’s attempt to maximise yield led it to bridge assets — something Maya never explicitly authorised.</p><p><strong>Assumption 7: Conflicts will be visible.</strong><br>Maya assumed that if agents conflicted, she’d see it and decide. She didn’t. The conflict played out in mempool contention and failed transactions.</p><h3>Part Three: How ERC-8001 Changes the Story</h3><p>Let’s rewind. Same Maya. Same agents. Same protocols.</p><p>But now Maya’s wallet and agents operate on ERC-8001 intents rather than raw transactions.</p><h3>Maya Repays Her Loan (The ERC-8001 Version)</h3><p>Maya wants to repay 500 DAI. Instead of signing a transaction, she authorises an <strong>intent object</strong>:</p><pre>Intent:<br>  Action: &quot;Repay&quot;<br>  Amount: 500 DAI<br>  Recipient: [LendingProtocol vault address]<br>  Obligation reference: [Loan ID #4821]<br>  Constraints:<br>    - Max slippage: 0.5%<br>    - Expiry: 24 hours<br>    - No additional actions triggered<br>    - No callbacks to untrusted contracts<br>  Authorized fulfillers: [List of approved solvers]</pre><p>When Maya clicks “Confirm,” she’s not signing a blank check for execution. She’s authorising a <strong>bounded commitment</strong>.</p><p>The protocol receives this intent. It can fulfil it in multiple ways — direct transfer, routed through a DEX, handled by a solver — but <strong>all fulfilment paths must stay within the intent’s bounds</strong>.</p><p>If the protocol attempts to trigger a callback, the intent specification disallows it. If a solver tries to initiate a “portfolio optimisation” as part of the repayment, that falls outside the authorised scope. The intent acts as a <strong>verification layer</strong> that execution must satisfy.</p><p>Maya’s wallet displays the actual authorised commitment. Not a summary. The thing itself.</p><h3>Maya’s Agents Coordinate (The ERC-8001 Version)</h3><p>Now the three agents don’t operate on raw execution. They propose <strong>intents</strong> that compete for Maya’s authorisation.</p><p>RebalanceAgent proposes:</p><pre>Intent: &quot;Adjust collateral ratio&quot;<br>Target: Maintain health factor &gt; 1.5<br>Scope: May move collateral between approved protocols<br>Constraints: Must not conflict with active payment intents</pre><p>YieldOptimizer proposes:</p><pre>Intent: &quot;Optimize yield&quot;<br>Target: Maximize APY on idle assets<br>Scope: Approved yield protocols only<br>Constraints: Must preserve collateral ratios required by active obligations</pre><p>PaymentSettler proposes:</p><pre>Intent: &quot;Settle obligation&quot;<br>Amount: 100 USDC<br>Deadline: [timestamp]<br>Priority: Settlement must complete within 24 hours</pre><p>These intents enter a <strong>coordination layer</strong> — a system that checks for conflicts before any execution begins.</p><p>The coordination layer sees that YieldOptimizer wants to bridge assets that PaymentSettler needs for settlement. It flags the conflict. Maya receives a notification: <em>Your yield optimisation strategy may interfere with an upcoming payment. Which takes priority?</em></p><p>Maya chooses. The system records her preference. PaymentSettler’s intent is marked as higher priority. YieldOptimizer’s intent is modified to exclude the assets needed for settlement.</p><p>No conflicting transactions. No failed settlements. No locked collateral.</p><h3>The Trust Model Shift</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/978/1*mu1lyM44Dt95-mXQqe4JUg.png" /></figure><h3>The Deeper Point About Trust</h3><p>ERC-8001 doesn’t eliminate trust. It <strong>makes trust legible</strong>.</p><p>In the old model, Maya trusted blindly. She signed transactions without understanding their full scope. She authorised agents without knowing how they’d interact. Her trust was distributed across invisible assumptions.</p><p>In the ERC-8001 model, Maya’s trust is <strong>bounded, explicit, and verifiable</strong>. She authorises intents with clear constraints. She can audit what each agent is permitted to do. When conflicts arise, the system surfaces them rather than silently failing.</p><p>The trust hasn’t disappeared. It’s been <strong>moved from execution to intent</strong>.</p><p>That’s the meaningful shift.</p><h3>The Stack in Practice</h3><p><strong>Layer 1: Account Capability (ERC-7702, ERC-4337)</strong><br>Defines what accounts can do. Enables programmable execution. Introduces dynamic behaviour.</p><p><strong>Layer 2: Safe Execution Patterns (mailbox, pull settlement, delayed execution)</strong><br>Reduces exposure to unsafe callbacks. Separates acceptance from execution. Limits immediate side effects.</p><p><strong>Layer 3: Semantic Coordination (ERC-8001)</strong><br>Defines what parties agreed to. Makes intent explicit. Provides verifiable bounds for execution.</p><p>ERC-8001 is a Final standard. That means builders can depend on this layer now — it’s not a moving target or a proposed architecture. The semantic coordination layer is stable, specified, and ready for integration.</p><p>Maya’s repayment flows through all three layers. ERC-7702 lets her account behave flexibly. Safe patterns ensure her repayment doesn’t trigger unexpected callbacks. ERC-8001 ensures the repayment intent is bounded, displayed, and enforceable.</p><p>This stack isn’t theoretical. It’s available now.</p><h3>The Value Proposition in One Scene</h3><p><strong>Old World:</strong></p><p>Maya signs. Her transaction touches seven contracts. Three agents fight over her assets. She doesn’t know that this happened until she checks her balance and sees unexpected changes.</p><p><strong>ERC-8001 World:</strong></p><p>Maya authorises an intent. The system shows her: <em>Here’s what you’re agreeing to. Here are the bounds. Here’s what falls outside those bounds and won’t be executed.</em> Her agents propose intents that enter a coordination layer. Conflicts surface before execution. Maya resolves them. Fulfilment happens within verified bounds.</p><h3>The Takeaway</h3><p>If you’re building in Ethereum’s evolving stack, the question isn’t whether complexity will increase. It already has. ERC-7702 makes accounts more dynamic. Agents make execution more autonomous. Protocols make interactions more interconnected.</p><p>The question is whether that complexity remains <strong>invisible</strong> — hidden in execution paths users can’t see — or becomes <strong>legible</strong> — expressed in intent objects users can understand, verify, and bound.</p><p>ERC-8001 establishes legibility as a first-class primitive. It says: the future of informed signing isn’t better transaction decoding. It’s a higher-order model where users authorise meaning, not execution.</p><p>Maya’s story makes the case.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aed4e99db20a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why AI Agents on Ethereum Need a Stack, Not a Single Standard]]></title>
            <link>https://medium.com/coinmonks/why-ai-agents-on-ethereum-need-a-stack-not-a-single-standard-5115ccc3079e?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/5115ccc3079e</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[erc8004]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Mon, 06 Apr 2026 05:34:10 GMT</pubDate>
            <atom:updated>2026-04-06T05:34:10.870Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SenziJ9JaZ9L_dEgt7qb5w.png" /><figcaption>How ERC-725, ERC-8001, ERC-8107, ERC-8004, and ERC-8183 fit together, and where the gaps remain</figcaption></figure><h3>How ERC-725, ERC-8001, ERC-8107, ERC-8004, and ERC-8183 fit together, and where the gaps remain</h3><p>I used to think the problem was straightforward.</p><p>If AI agents were going to operate on Ethereum, they needed one standard. A shared format for intents. A clear lifecycle. Verifiable acceptances. A simple way for multiple parties to agree before anything is executed.</p><p>That instinct points directly at <strong>ERC-8001</strong>. The EIP defines a minimal, single-chain primitive for multi-party agent coordination: an initiator posts an intent, participants provide verifiable acceptances, and once the required set is present and fresh, the intent becomes executable. The spec is intentionally narrow and explicitly leaves privacy, reputation, threshold policies, bonding, and cross-chain semantics to optional modules rather than forcing everything into the core.</p><p>At first, that felt like enough.</p><p>Then the real world showed up.</p><h3>The first question: can agents coordinate?</h3><p>Imagine a real agent system.</p><p>One agent finds an opportunity.<br> One validates the data.<br> One handles execution.<br> One manages capital, permissions, or custody.</p><p>Inside a closed platform, that is manageable because the platform quietly decides identity, trust, permissions, and orchestration. But open systems on Ethereum cannot rely on hidden assumptions. They need open standards.</p><p>That is why ERC-8001 matters. It gives agents a common coordination kernel: how to represent an intent, how to accept it, and when the system should regard it as executable. It standardises typed data, lifecycle, and verification rules, but stops short of becoming an all-in-one agent framework. That restraint is not a flaw. It is the design choice that makes the rest of the stack possible.</p><p>But once coordination is solved, a deeper problem appears.</p><p>Because coordination is not identity.</p><h3>The second question: who is actually coordinating?</h3><p>A valid signature proves that <em>a key was</em> signed. It does not tell me whether the signer is a durable programmable account, whether it can store metadata, or whether it can act as a stable agent identity over time.</p><p>That is where <strong>ERC-725</strong> enters the story.</p><p>ERC-725 defines two building blocks: <strong>ERC725X</strong> for generic execution and <strong>ERC725Y</strong> for generic key/value data storage. The EIP frames these as reusable components for smart contract accounts, upgradeable metadata, and long-lived account systems. In practical terms, ERC-725 can act as a programmable identity and execution container for an agent.</p><p>That makes ERC-725 a useful <strong>agent account substrate</strong>. An agent could use ERC725Y to expose metadata and ERC725X to execute approved actions. But ERC-725 does not define multi-party coordination or trust. It is an account and identity container, not a coordination or reputation system. Its own security section warns that generic execution, especially DELEGATECALLIt can be dangerous because it can alter state and ownership-related storage.</p><p>So now the architecture starts to come into focus:</p><ul><li>ERC-725 gives me a programmable account.</li><li>ERC-8001 gives me formal coordination.</li></ul><p>And yet one crucial question remains.</p><h3>The third question: Why should I trust any of these agents?</h3><p>This is where most open agent systems become fragile.</p><p>It is not enough for agents to identify themselves. It is not enough for them to sign messages. The real issue is whether agents can be discovered, evaluated, and trusted without collapsing back into a centralised platform.</p><p>That is the problem <strong>ERC-8004</strong> is trying to address. Its abstract says the protocol is meant to allow parties to “discover, choose, and interact with agents across organisational boundaries without pre-existing trust,” thereby enabling open-ended agent economies. It does this through three registries: <strong>Identity</strong>, <strong>Reputation</strong>, and <strong>Validation</strong>. It also makes trust models pluggable, ranging from client feedback to stake-secured re-execution, zkML proofs, and TEE oracles.</p><p>This was the moment my thinking changed.</p><p>ERC-8001 is not the full agent stack. It is the coordination core.<br> ERC-8004 is trying to become the broader discovery, reputation, and validation layer around that core.<br> ERC-725 can sit underneath as the programmable account substrate.</p><p>But there was still one more missing piece.</p><p>Because broad discovery and reputation systems are useful, but in practice, many builders want a simpler question answered first:</p><p><strong>Does this agent belong to someone I trust, or to someone trusted by someone I trust?</strong></p><h3>The fourth question: what if trust were human-readable?</h3><p>That is where <strong>ERC-8107</strong> becomes interesting.</p><p>The ERC index currently lists <strong>8107, “ENS Trust Registry for Agent Coordination,”</strong> and the Fellowship of Ethereum Magicians thread describes it as a trust registry where agents establish and query transitive trust relationships using ENS names as identifiers. The proposal uses trust levels such as Unknown, None, Marginal, and Full, and says trust can propagate through signature chains inspired by the GnuPG web-of-trust model. The thread explicitly positions it as a trust module for ERC-8001-style coordination.</p><p>That positioning matters.</p><p>ERC-8107 is not trying to replace coordination. It is not trying to replace programmable accounts. It aims to address <strong>participant selection</strong> for open agent coordination using ENS-linked identities and a trust graph. In other words, ERC-8001 answers “how do agents formally agree?”, while ERC-8107 helps answer “which agents should even be allowed into the coordination set?”</p><p>But the web-of-trust model has real weaknesses.</p><p>PGP-style trust systems have historically struggled with bootstrapping and Sybil resistance. ENS adds some cost and ownership structure to identity, which helps, but it does not eliminate the problem. A trust graph is only as useful as its first meaningful edges. If no one knows a new agent, or no trusted party is willing to attest to it, the graph remains sparse. That is not a reason to dismiss ERC-8107. It is a reason to treat it as a serious trust-gating proposal that still needs real-world testing and careful policy design.</p><p>At that point, the stack looked much clearer:</p><ul><li><strong>ERC-725</strong> = programmable account/identity substrate</li><li><strong>ERC-8107</strong> = ENS-based trust gating</li><li><strong>ERC-8001</strong> = multi-party coordination primitive</li><li><strong>ERC-8004</strong> = broader discovery/reputation/validation layer</li></ul><p>And then I realised there was still another missing piece.</p><p>Because agents do not only need to identify, trust, discover, and coordinate.</p><p>They also need to <strong>do business</strong>.</p><h3>The fifth question: How do agents actually get paid for work?</h3><p>This is where <strong>ERC-8183</strong> matters.</p><p>ERC-8183, <strong>“Agentic Commerce,”</strong> is much more concrete than the rest of the stack. It defines a job with an escrowed budget, a state machine centred on <strong>Open</strong>, <strong>Funded</strong>, <strong>Submitted</strong>, and terminal outcomes, and an evaluator who may mark the job completed or rejected. The client funds the job, the provider submits work, and the evaluator approves or rejects it according to the state machine. The EIP also explicitly discusses composition with ERC-8004 for reputation and validation.</p><p>That makes ERC-8183 different from ERC-8001.</p><p>ERC-8001 is a <strong>general coordination primitive</strong>.<br> ERC-8183 is a <strong>commerce-specific escrow workflow</strong>.</p><p>ERC-8001 asks: “How do multiple agents coordinate around an intent?”<br> ERC-8183 asks: “How do a client, provider, and evaluator run a paid job with escrow and completion logic?”</p><p>That distinction is important because it means ERC-8183 is not really a replacement for the stack below it. It is better understood as an <strong>application-layer protocol built on top of it</strong>. The EIP is narrow by design: it hardcodes a job flow, a role model, and an evaluator-centric completion process. That is exactly what you want from a vertical commerce protocol, but it is not the same thing as a general-purpose coordination layer.</p><h3>The real answer: it is not one standard, it is a stack</h3><p>I had been looking for a single standard to solve everything.</p><p>There isn’t one.</p><p>There is a stack.</p><p><strong>ERC-725</strong> provides agents with an account and an execution surface.<br> <strong>ERC-8004</strong> helps them become discoverable and evaluable in open environments.<br> <strong>ERC-8107</strong> helps coordinators gate participation through ENS-native trust relationships.<br> <strong>ERC-8001</strong> provides participants with a formal way to coordinate on intents.<br> <strong>ERC-8183</strong> gives them a concrete commerce pattern for paid work, escrow, and delivery.</p><p>Once I saw it that way, the standards stopped looking like competitors.</p><p>They started looking like answers to different user-journey questions.</p><h3>The user journey</h3><p><strong>Step 1: Who am I?</strong><br> My agent needs a programmable account, metadata, and execution capabilities. That is where ERC-725 helps.</p><p><strong>Step 2: Who can I find?</strong><br> My agent needs a way to discover other agents across organisational boundaries. That is the direction ERC-8004 is taking with identity, reputation, and validation registries.</p><p><strong>Step 3: Who do I trust?</strong><br> I may want a direct, human-readable trust graph based on ENS-linked identities and transitive trust. That is the role ERC-8107 is proposing.</p><p><strong>Step 4: How do we actually agree and act?</strong><br> Once I know the participants, I still need a minimal, auditable protocol for multi-party intent acceptance and execution readiness. That is ERC-8001.</p><p><strong>Step 5: How do we structure paid work?</strong><br> Once agents can identify, discover, trust, and coordinate, they still need a concrete economic workflow. That is where ERC-8183 comes in, providing them with a job, escrow, an evaluator, and a settlement path.</p><h3>The picture that changed everything</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F2qjkudaV2cgH0QUFyNboQ.png" /></figure><p>This is not the only valid way to compose these standards, but it is the clearest mental model I have found. ERC-725 gives the account substrate. ERC-8001 defines the coordination kernel. ERC-8107 helps determine who is trusted enough to participate. ERC-8004 broadens that into discovery, portable reputation, and validation. ERC-8183 sits above them as a concrete commerce protocol for jobs and escrow.</p><p>The ordering is not fully settled. You could argue that trust filtering under ERC-8107 should occur before broad discovery under ERC-8004. Others might argue that discovery must come first because you cannot evaluate trust until you know who exists. The right ordering may depend on the use case, and the standards may evolve to clarify those relationships.</p><h3>What the stack costs</h3><p>There is a catch.</p><p>Composing multiple standards on Ethereum can get expensive. Each layer can add deployments, storage writes, signature verifications, and cross-contract calls. A coordination flow that touches an account layer, a trust layer, and a coordination layer in one path may be too costly for small-value tasks on mainnet.</p><p>Layer 2 networks change that calculus. Cheaper execution environments make stacked standards much more practical. But they introduce new questions around deployment location, cross-chain verification, bridging, and fragmented liquidity or identity context. The economics are not a reason to abandon the stack approach. They are a reason to design for cost from the start.</p><h3>A note on maturity</h3><p>There is another reality I have to acknowledge.</p><p>Not all of these standards are at the same stage.</p><p><strong>ERC-8001 is the most mature piece of this stack.</strong> Its EIP page is published as a Standards Track ERC, while <strong>ERC-8004</strong> is explicitly marked <strong>Draft</strong> on its EIP page. <strong>ERC-8183</strong> currently shows <strong>status is Open</strong> on its EIP page, and <strong>ERC-8107</strong> is listed on the ERC index and discussed on Magicians, which makes it better understood as an earlier-stage proposal still working through review and feedback. The EIP process itself distinguishes between Draft, Review, Last Call, Final, and other states, and those labels matter for implementers.</p><p>This does not weaken the stack thesis. It strengthens it.</p><p>It means the coordination kernel is relatively stable, while discovery, trust, and commerce layers are still evolving around it. Builders can treat ERC-8001 as the anchor and approach the upper layers with greater flexibility, diligence, and a higher expectation of change.</p><h3>The bootstrapping problem</h3><p>There is one more gap the stack does not fully address.</p><p>Each of these standards becomes valuable only when there is already a network using them. An agent with a programmable account is not useful if no other agent can discover it. A trust graph is empty until someone populates it. A commerce protocol only matters when there are already clients, providers, and evaluators willing to use it.</p><p>This is a classic chicken-and-egg problem. Early adopters pay integration costs before they receive full network benefits. The standards layer does not solve this on its own. Applications, platforms, and incentives do. Builders should expect an adoption curve in which the first integrations incur disproportionate costs and should design economic and social incentives that reward early participation.</p><h3>What builders should take away?</h3><p>If you are building agent systems on Ethereum, the wrong question is:</p><p><strong>Which one of these standards wins?</strong></p><p>The better questions are:</p><ul><li>Who is the agent?</li><li>How is the agent represented?</li><li>How is trust established?</li><li>How are other agents discovered?</li><li>How do multiple agents formally agree?</li><li>How is paid work structured and settled?</li><li>What does this cost in gas, and where should it run?</li><li>Which of these standards are actually mature enough to build on today?</li><li>How do I bootstrap the first participants?</li></ul><p>Those are different problems. They deserve different layers.</p><p>That is why ERC-8001’s minimalism is a strength rather than a weakness. Keeping the coordination kernel small leaves room for identity and account layers like ERC-725, trust modules like ERC-8107, broader discovery and validation systems like ERC-8004, and vertical protocols like ERC-8183 to evolve around it without overloading the core.</p><h3>The real breakthrough</h3><p>I stopped asking one standard to do everything.</p><p>I started seeing the future of agentic Ethereum systems as a stack.</p><p>The next phase of agent infrastructure will not be won by closed platforms with opaque trust assumptions. It will be built through open, composable standards that let identity, trust, discovery, coordination, and commerce work together without collapsing into centralisation.</p><p>But getting there means acknowledging the gaps: the gas costs, the draft-status layers, the bootstrapping challenges, and the fact that trust is always harder than diagrams make it look.</p><p>The stack is the right mental model.</p><p>The implementation will be messier than the picture.</p><p>Build anyway.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5115ccc3079e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/coinmonks/why-ai-agents-on-ethereum-need-a-stack-not-a-single-standard-5115ccc3079e">Why AI Agents on Ethereum Need a Stack, Not a Single Standard</a> was originally published in <a href="https://medium.com/coinmonks">Coinmonks</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From PixelBattle to Intent-Driven Gameplay: Evolving Blockchain Games with ERC-8001 and x402]]></title>
            <link>https://medium.com/@kwame.bryan/from-pixelbattle-to-intent-driven-gameplay-evolving-blockchain-games-with-erc-8001-and-x402-cb3cd706a360?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/cb3cd706a360</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[gaming]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 19:43:28 GMT</pubDate>
            <atom:updated>2026-02-22T19:43:28.787Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/642/1*2JNUDX-C2EVW45j5_lTraw.png" /></figure><h3>Revisiting PixelBattle: A Simple Idea That Started It All</h3><p>Last year, I published a tutorial introducing <a href="https://medium.com/@kwame.bryan/introduction-to-building-a-blockchain-game-with-solidity-25bc2f791353">PixelBattle</a>. This minimal Solidity contract allows four players to deposit ETH into a pot, and the owner declares a winner who receives the total prize. That contract was intentionally simple, an educational bridge for beginners learning how game mechanics can live on-chain. But it also reflected the early design era of blockchain games: centralised control, fixed rules, and implicit trust in the game owner. It worked as a proof of concept, but it wasn’t trustless, auditable, or autonomous.</p><h3>Why We Needed an Upgrade</h3><p>As Web3 gaming matured, expectations evolved: players demanded provable fairness, developers needed modular standards, and ecosystems like SKALE and Base began integrating agentic coordination layers. The original PixelBattle had pain points: owner centralisation, locked funds, no verifiable randomness, and no audit trail. We rebuilt it, this time with <a href="https://eips.ethereum.org/EIPS/eip-8001">ERC-8001</a> and <a href="https://www.x402.org/">x402</a>.</p><h3>The Philosophy: Agentic Verification over Trust</h3><p>At the core of the new design is ERC-8001, an Ethereum standard that defines verifiable coordination through intents. Instead of relying on a single owner or oracle, actions are authorised by signed multi-party agreements, called intents. In PixelBattleV2, a <strong>BattleResultIntent</strong> struct contains round details, is signed by multiple referees, and is verified by a Registry that enforces quorum and policy rules. This ensures fairness through cryptographic verification rather than trust.</p><h3>Integrating x402: Encrypted Tournaments and Receipts</h3><p>While ERC-8001 handles coordination, x402 adds encrypted communication and proof of settlement between participants. Each match emits an <strong>x402ReceiptRecorded</strong> event that links the round outcome to an encrypted, off-chain tournament receipt, enabling verifiable audit trails without leaking private player data.</p><h3>Inside PixelBattleV2: Modern Architecture</h3><p>PixelBattleV2 introduces a modern, secure architecture integrating ERC-8001 and x402. It includes modular verification, dispute windows, pull-based payouts, and emergency refunds, adhering to CEI best practices and game-theoretic fairness principles.</p><h3>The Flow of a Fair Game</h3><p>1. Players join and deposit 0.08 ETH each<br>2. Round fills → ERC-8001 Intent proposed<br>3. Registry verifies signatures &amp; quorum<br>4. Result locked; dispute window begins<br>5. Winner claims prize via pull-payment<br>6. Optional: x402 receipt recorded for audit</p><h3>The Broader Impact: Agentic Esports and Beyond</h3><p>PixelBattleV2 represents a blueprint for autonomous, intent-driven game logic. It unlocks new possibilities for agentic esports, composable tournaments, cross-game identities, and fair play by default, turning verifiable coordination into a core gameplay mechanic.</p><h3>Developer Takeaway</h3><p>This rebuild demonstrates a shift in design philosophy: from ‘code that runs a game’ to ‘contracts that verify behaviour’. With ERC-8001 and x402, games become self-auditing systems that enforce verifiable coordination between players and agents.</p><h3>What’s Next</h3><p>Next, we’ll expand into multi-round tournament coordinators that aggregate x402 receipts, integrate ERC-4337 smart accounts for AI-driven agents, and build a Unity/HTML5 SDK for game developers to easily plug in these agentic systems.</p><h3>Closing Thoughts</h3><p>PixelBattle began as a simple Solidity exercise but has evolved into a demonstration of Ethereum’s next-generation coordination layer. By combining <a href="https://eips.ethereum.org/EIPS/eip-8001">ERC-8001</a> intents and <a href="https://www.x402.org/">x402</a> receipts, we’re moving toward a world where blockchain games don’t just store assets, they store trust, proof, and intent.</p><p>Follow Kwame on <a href="https://github.com/kbryan">GitHub</a> and <a href="https://x.com/elijahnomad">X (Twitter)</a> for code, test suites, and future experiments with agentic tournaments and decentralised coordination frameworks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cb3cd706a360" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When AI Agents Need to Pay Across Chains: A Standard Emerges.]]></title>
            <link>https://medium.com/@kwame.bryan/when-ai-agents-need-to-pay-across-chains-a-standard-emerges-a2b4c3d8cdca?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2b4c3d8cdca</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[gamefi]]></category>
            <category><![CDATA[web3-game]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Sat, 27 Dec 2025 11:57:04 GMT</pubDate>
            <atom:updated>2026-02-06T23:34:49.256Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How ERC-8001 and Trails via Sequence are building the rails for autonomous cross-chain coordination</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/868/1*0_rxPIojvuZy1Q6a1COQXg.png" /></figure><h3>The 3 AM Problem</h3><p>It’s 3 AM. Mia’s yield farming agent has been running for six hours, quietly optimising her DeFi positions across seven chains. It spotted an opportunity: a 4.2% APY difference between an Arbitrum lending pool and a new vault on Base.</p><p>The agent knows what to do. It needs to:</p><ol><li>Withdraw from the Arbitrum position</li><li>Bridge the USDC to Base</li><li>Deposit into the new vault</li></ol><p>Simple.</p><p>Except Mia’s agent is stuck. It can see the opportunity. It can calculate the gas costs. But when it tries to execute, it hits a wall that every developer building autonomous systems has encountered:</p><p><strong>There’s no standard way for agents to coordinate cross-chain payments.</strong></p><p>The agent can talk to Arbitrum. It can speak to Base. But asking it to move value between them seamlessly? That requires stitching together bridge APIs, DEX aggregators, and gas estimation services, each with its own authentication, data formats, and failure modes.</p><p>Mia wakes up to find the opportunity gone. Her agent logged 47 failed attempts to parse bridge response formats.</p><h3>“Why Can’t Agents Just… Pay?”</h3><p>I’ve been building <a href="https://eips.ethereum.org/EIPS/eip-8001">ERC-8001</a>, an Ethereum standard for multi-party agent coordination. The motivation came from a simple observation:</p><blockquote><em>Agents in DeFi/Web3 gaming and Agentic Commerce need to act together without a trusted coordinator. Existing intent standards define single-initiator flows and don’t specify multi-party agreement.</em></blockquote><p>ERC-8001 provides the minimal primitive: an initiator’s EIP-712 intent plus per-participant acceptances. The intent becomes executable only when the required signatures are present.</p><p>But here’s what I kept hearing from developers trying to use it:</p><p><em>“This is great for coordinating actions on a single chain. But my agents operate across Arbitrum, Base, Skale and Optimism. How do I express ‘move value from here to there’?”</em></p><p>The core spec deliberately stays minimal. Privacy, thresholds, bonding, and <strong>cross-chain</strong> are left to extension modules. I did this for my own sanity as an EIP author, but also for great ERC’s reviewers like Sam Wilson.</p><p>Cross-chain needed its own standard.</p><h3>Enter Trails</h3><p>While wrestling with this problem, I came across <a href="https://docs.trails.build/">Trails</a>, a cross-chain orchestration protocol built by <a href="https://sequence.xyz/">Sequence</a>. Their tagline caught my attention:</p><blockquote>“1-click transactions from any wallet, seamlessly, with unified user liquidity across all chains.”</blockquote><p>I started reading their architecture docs, and something clicked.</p><p>Trails are built on <strong>intents</strong>. A user (or agent) expresses what they want, and as an example: “send 100 USDC from Arbitrum to Base and deposit into this vault.” Now, Trails will automatically figure out the optimal path, bridges, DEXs, and gas.</p><p>But here’s what really got me: their <a href="https://docs.trails.build/architecture/how-it-works">security model</a>.</p><blockquote>“Intent-Scoped Authorization: Intent addresses are only used to trustlessly authorize the specific transaction calldata the user has explicitly permitted nothing more.”</blockquote><p>This is precisely the philosophy behind ERC-8001. Scoped permissions. Explicit authorisation. No custody.</p><p>They’re using EIP-712 signatures for deposit permits. They track intent hashes to protect against replay attacks. They enforce deadlines.</p><p><strong>Trails had essentially built an ERC-8001-compatible executor without calling it that.</strong></p><h3>A Conversation Over Coffee (Virtually)</h3><p>I reached out to the Trails team. The conversation was short and sweet:</p><p><strong>Me:</strong> “Your architecture is sick and maps almost perfectly to what we’re building with ERC-8001. What if Trails became the standard cross-chain executor for the agent ecosystem?”</p><p><strong>Them:</strong> “What would that look like technically?”</p><p><strong>Me:</strong> “A thin interface wrapper. Your existing QuoteIntent → CommitIntent → ExecuteIntent flow already matches the pattern. We&#39;d standardise the input format so any ERC-8001 agent can route through Trails without custom integration.&quot;</p><p>The lightbulb moment came when we mapped the data structures:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wsiGcRF_lwLdqA07NW4XOg.png" /></figure><p>It’s nearly 1:1.</p><h3>What We Built: ERC-8001-XCHAIN</h3><p>ERC-8001-XCHAIN (currently being built out, stay tuned) is the cross-chain extension module for ERC-8001. It defines:</p><h3>1. A Standard Intent Type</h3><p>solidity</p><pre>struct CrossChainPaymentIntent {<br>    // ERC-8001 core fields<br>    address initiator;<br>    uint256 nonce;<br>    uint256 deadline;<br>    <br>    // Cross-chain extension<br>    Origin origin;<br>    Destination destination;<br>    Constraints constraints;<br>}</pre><p>This captures everything an agent needs to express: where value comes from, where it goes, what to do on arrival, and what constraints to enforce.</p><h3>2. The Executor Interface</h3><p>solidity</p><pre>interface IERC8001CrossChainExecutor {<br>    function quote(CrossChainPaymentIntent calldata intent) <br>        external view returns (Quote memory);<br>    <br>    function execute(<br>        CrossChainPaymentIntent calldata intent,<br>        bytes calldata signature<br>    ) external payable returns (bytes32 intentHash);<br>    <br>    function executeCoordinated(<br>        CrossChainPaymentIntent calldata intent,<br>        bytes calldata initiatorSignature,<br>        Acceptance[] calldata acceptances,<br>        bytes[] calldata acceptanceSignatures,<br>        uint8 threshold<br>    ) external payable returns (bytes32 intentHash);<br>}</pre><p>Any protocol — Trails, Across, Socket — can implement this interface. Agents don’t need to know which executor they’re using. They express intents in a standard format and let the ecosystem route optimally.</p><h3>3. Multi-Party Coordination</h3><p>Here’s where ERC-8001’s power shows up. The executeCoordinated function accepts multiple acceptances:</p><p>solidity</p><pre>Acceptance[] calldata acceptances,<br>bytes[] calldata acceptanceSignatures,<br>uint8 threshold</pre><p>This enables:</p><ul><li><strong>Multi-sig treasury management:</strong> 3-of-5 signers approve a cross-chain rebalance</li><li><strong>Agent swarms:</strong> Multiple bots coordinate a complex arbitrage</li><li><strong>Guarded execution:</strong> A risk management agent must co-sign high-value transfers</li></ul><p>All use the same intent format, the same signature scheme, and the same execution path.</p><h3>Back to Mia’s Agent</h3><p>Let’s revisit that 3 AM scenario. With ERC-8001-XCHAIN and Trails, here’s what Mia’s agent does:</p><p>typescript</p><pre>import { CrossChainPaymentIntent } from &#39;@erc8001/xchain&#39;;<br>import { TrailsExecutor } from &#39;@erc8001/trails-adapter&#39;;<br><br>// Agent identifies the opportunity<br>const opportunity = await analyzer.findBestYield();<br>// Express the intent in standard format<br>const intent: CrossChainPaymentIntent = {<br>    initiator: agentAddress,<br>    nonce: await getNonce(agentAddress),<br>    deadline: Math.floor(Date.now() / 1000) + 3600,<br>    <br>    origin: {<br>        chainId: 42161,  // Arbitrum<br>        token: USDC_ARBITRUM,<br>        amount: parseUnits(&#39;1000&#39;, 6)<br>    },<br>    <br>    destination: {<br>        chainId: 8453,  // Base<br>        token: USDC_BASE,<br>        minAmount: parseUnits(&#39;995&#39;, 6),  // 0.5% slippage<br>        recipient: VAULT_ADDRESS,<br>        execution: {<br>            target: VAULT_ADDRESS,<br>            data: vault.interface.encodeFunctionData(&#39;deposit&#39;, [<br>                parseUnits(&#39;995&#39;, 6),<br>                miaAddress<br>            ]),<br>            value: 0n<br>        }<br>    },<br>    <br>    constraints: {<br>        maxFeeUsd: parseUnits(&#39;5&#39;, 6),  // Max $5 in fees<br>        maxDuration: 300,  // Complete within 5 minutes<br>        preferredExecutor: bytes32(0),  // Any executor<br>        allowPartialFill: false<br>    }<br>};<br>// Sign and execute<br>const signature = await agent.signTypedData(domain, types, intent);<br>const executor = new TrailsExecutor(trailsClient);<br>const intentHash = await executor.execute(intent, signature);<br>// Monitor completion<br>executor.onStatusUpdate(intentHash, (status) =&gt; {<br>    if (status === &#39;Completed&#39;) {<br>        logger.info(&#39;Cross-chain deposit successful&#39;, {<br>            output: status.actualOutput,<br>            fees: status.actualFeeUsd<br>        });<br>    }<br>});</pre><p>One intent. One signature. Trails handles bridge selection, DEX routing, and gas. Mia’s agent captures the opportunity.</p><p>When she wakes up, instead of 47 error logs, she sees:</p><pre>[03:14:22] Intent submitted: 0xabc123...<br>[03:14:45] Origin confirmed on Nebula<br>[03:15:12] Bridging via CCTP<br>[03:16:33] Destination execution successful<br>[03:16:33] Deposited 997.42 USDC into vault</pre><h3>Why This Matters</h3><h3>For Agent Developers</h3><p>You no longer need to integrate five different bridge APIs. Express your intent in a standard format, and the ecosystem handles routing.</p><p>typescript</p><pre>// Before: Custom integration for each bridge<br>const lifiQuote = await lifi.getQuote(...);<br>const acrossQuote = await across.getQuote(...);<br>const socketQuote = await socket.getQuote(...);<br>// Compare, handle errors, manage state...<br><br>// After: Standard interface<br>const quote = await executor.quote(intent);<br>const result = await executor.execute(intent, signature);</pre><h3>For Protocol Builders</h3><p>Implementing IERC8001CrossChainExecutor makes your protocol accessible to the entire ERC-8001 agent ecosystem. You don&#39;t need individual integrations with every agent framework.</p><h3>For Users</h3><p>When your wallet, your agent, and your DeFi protocols all speak the same language, cross-chain becomes invisible. You think in terms of outcomes (“deposit into this vault”), not infrastructure (“bridge to Base, swap to USDC, approve the vault, call deposit…”).</p><h3>The Bigger Picture</h3><p>ERC-8001-XCHAIN is just one extension module. The core ERC-8001 spec is designed for composability:</p><pre>ERC-8001 (Core)<br>│<br>├── Intent + Acceptance pattern<br>├── Canonical participant lists<br>├── Replay protection<br>│<br>└── Extensions<br>    ├── ERC-8001-XCHAIN  ← Cross-chain payments<br>    ├── ERC-8001-THRESHOLD  ← Threshold signatures<br>    ├── ERC-8001-PRIVACY  ← Private intents<br>    └── ERC-8001-BONDS  ← Economic security<br>    └── ERC-8001-EXT  ← Extensions we have not thought of</pre><p>Each extension addresses a specific need while inheriting the core security model. Cross-chain is first because it’s the most immediate pain point, and there is some incentive.</p><p><strong>EDIT:</strong></p><p>The team at ERC-8001 have proposed a new standard, <a href="https://ethereum-magicians.org/t/erc-8107-ens-trust-registry-for-agent-coordination/27200">ERC-8107: ENS Trust Registry for Agent Coordination</a></p><h3>What’s Next</h3><p><strong>ERC-8001</strong> is now a final standard, and the team can have some fun with it. The core spec focuses on the minimal coordination primitive intent plus acceptances, nothing more.</p><p><strong>ERC-8001-XCHAIN</strong> is being developed as the first official extension. We’re hoping to work with the Trails team to validate the interface against production infrastructure.</p><p><strong>For developers</strong> who want to start building:</p><ul><li><a href="https://docs.trails.build/">Trails Documentation</a> — Understand the underlying infrastructure</li><li><a href="https://eips.ethereum.org/EIPS/eip-8001">ERC-8001 Spec</a> — Core agent coordination standard</li></ul><p><strong>For protocol teams</strong> interested in becoming ERC-8001 executors:</p><ul><li>The interface is straightforward — check IERC8001CrossChainExecutor <strong>still in development</strong></li><li>We’re building adapters for major cross-chain protocols</li><li>Reach out if you want early integration support</li></ul><h3>Closing Thought</h3><p>The future of DeFi isn’t users manually clicking through multi-step transactions. Its agents express high-level intents and infrastructure competing to fulfil them optimally.</p><p>For that future to work, we need standards. Not proprietary APIs. Not walled gardens. Open standards that let agents coordinate across chains, across protocols, across trust boundaries.</p><p>ERC-8001 is the coordination layer. Trails is the execution layer. Together, they’re building the rails.</p><p>Mia’s agent doesn’t care which bridge moves her USDC. It cares about the 4.2% APY difference. The infrastructure should be invisible.</p><p><strong>That’s what we’re building.</strong></p><p>ERC-8001 in-game example with Agentic NPCs</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fy8LKYQ6435E%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dy8LKYQ6435E&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fy8LKYQ6435E%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/3a14007c692c62e78805a5d382d5f21b/href">https://medium.com/media/3a14007c692c62e78805a5d382d5f21b/href</a></iframe><p><em>Kwame is the author of ERC-8001 and a tokenomics engineer focused on DeFi / Web3 gaming and Agentic Commerce. He’s currently building Spree Protocol @ Spree Finance, a yield aggregation system on Base.</em></p><h3>References</h3><ul><li><a href="https://docs.trails.build/">Trails Documentation</a></li><li><a href="https://docs.trails.build/sdk/hooks">Trails SDK Hooks</a></li><li><a href="https://docs.trails.build/architecture/how-it-works">Trails Architecture</a></li><li><a href="https://eips.ethereum.org/EIPS/eip-8001">ERC-8001: Agent Coordination Framework</a></li><li><a href="https://sequence.xyz/">Sequence</a> — Trails’ parent platform</li><li><a href="https://eips.ethereum.org/EIPS/eip-712">EIP-712: Typed Structured Data Hashing and Signing</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2b4c3d8cdca" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Economic Incentive Games with Trails SDK]]></title>
            <link>https://medium.com/@kwame.bryan/building-economic-incentive-games-with-trails-sdk-8e1eec4fcbcb?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e1eec4fcbcb</guid>
            <category><![CDATA[game-economy]]></category>
            <category><![CDATA[game-design]]></category>
            <category><![CDATA[game-development]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[ethereum]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Sat, 13 Dec 2025 16:43:17 GMT</pubDate>
            <atom:updated>2025-12-13T16:43:17.429Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*f-KMiJN6EuYQpgqAye_m7w.png" /></figure><h3>A Return to GameFi Fundamentals</h3><p><em>The infrastructure finally caught up with the vision</em></p><h3>GameFi Had a Problem</h3><p>Okay, it&#39;s 2021? Every game was a “play-to-earn revolution.” Players were quitting jobs to breed digital pets. The pitch was simple: play games, earn crypto, change your life. I know this well. During this time, I was working at ChainSafe on Web3.Unity and preaching the gospel of Web3 gaming.</p><p>Then reality hit.</p><p>Most GameFi projects failed not because the vision was wrong, but because the infrastructure wasn’t ready. Developers spent months building bridges, payment systems, and token swap mechanics instead of building <em>games</em>. Players needed five wallets, three bridges, and a PhD in DeFi to buy a sword. Glued together with maple syrup and hockey sticks.</p><p>The result? Games that weren’t fun. Economies that collapsed. A genre that became synonymous with Ponzinomics.</p><p>But here’s the thing: <strong>the core idea was right</strong>.</p><p>Games already have real economies. Players <em>should</em> own their assets. Developers <em>should</em> be able to monetise without predatory mechanics. If the game is good, and the assets are something the player wants. They are likely to partake in a monetary transaction.</p><p>What we needed wasn’t a new vision. We needed better infrastructure. These ideas were great in theory, but it was still too difficult for most to get there. The player doesn’t mind the setup, but this was the same every time they played. We did see advancements in concepts like embedded wallets and session keys. If you are an Ethereum EIP nerd, search ERC-4337 and ERC-6551. However, these developments have occurred over the last 3 years and are still not ready. Or, maybe it is.</p><h3>Enter Trails: GameFi’s Missing Layer</h3><p>Trails is a cross-chain payment and DeFi infrastructure built by Sequence. It abstracts away the complexity that killed early GameFi projects. I’ve been lucky enough to get access to the Trail API keys, and they are currently accepting new developers, so join the Telegram and ask.</p><p>Instead of building bridges, swap routers, and payment processors, you drop in a widget.</p><p>Instead of forcing players onto a specific chain, you meet them where they are, rather than having them think about how to create this transaction. The player only thinks of their <strong>intent</strong>. A monetary rail they are already familiar with.</p><p>One of the most significant setbacks for game studios that are Web3 curious. It is actually integrating Web3 game mechanics with economic incentives. Even though these ideas are already present in the game, they are building.</p><p>Trails has four core modes, and each one maps to a fundamental GameFi mechanic:</p><p>Trails Mode GameFi Use Case <strong>Pay</strong> In-game purchases, battle passes, NFT mints <strong>Swap</strong> Token exchanges, in-game currency conversion <strong>Fund</strong> Onboarding, wallet top-ups, fiat on-ramps <strong>Earn</strong> Staking rewards, yield on in-game assets</p><p>Let us try to break down each one and see where we would add this in a hypothetical game.</p><h3>Pay: The Shop That Actually Works</h3><p>Every game needs a shop. In traditional games, this is handled by Stripe or PayPal, or if you are large enough, you have your own in-house rails. In Web3, it’s been a nightmare.</p><p>Players have tokens scattered across chains. They don’t want to bridge. They don’t want to swap. They want to buy the item. The Trails team is currently investigating FIAT onramps and expects to release them within the first quarter of 2026. But who knows, we may get an early Christmas present for those who celebrate, of course.</p><p><strong>Trails Pay</strong> solves this:</p><pre>TrailsWidget.render(container, {<br>  mode: &#39;pay&#39;,<br>  <br>  // Your treasury receives USDC on Base<br>  toAddress: &#39;0xYourTreasury...&#39;,<br>  toAmount: &#39;10&#39;,<br>  toChainId: 8453,<br>  toToken: &#39;0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&#39;, // USDC<br>  <br>  // Player pays with whatever they have<br>  // ETH on Arbitrum? MATIC on Polygon? Doesn&#39;t matter.<br>  <br>  onCheckoutComplete: ({ sessionId }) =&gt; {<br>    // Grant the item<br>    grantBattlePass(playerId);<br>  }<br>});</pre><p><strong>What happens under the hood:</strong></p><ol><li>Widget detects players&#39; tokens across all chains</li><li>Player picks what to pay with</li><li>Trails routes the payment (swap + bridge if needed)</li><li>You receive exactly what you specified</li><li>onCheckoutComplete fires when funds arrive</li></ol><p>The player doesn’t think about chains. They think about the item they’re buying. That’s how it should be.</p><h3>Real Example: Battle Pass Purchase</h3><pre>const SHOP_ITEMS = {<br>  &#39;battle-pass&#39;: {<br>    price: 10,        // $10 USDC<br>    name: &#39;Season 3 Battle Pass&#39;,<br>    rewards: [&#39;exclusive-skin&#39;, &#39;1000-gems&#39;, &#39;xp-boost&#39;]<br>  },<br>  &#39;gem-pack&#39;: {<br>    price: 5,<br>    name: &#39;500 Gems&#39;,<br>    rewards: [&#39;500-gems&#39;]<br>  },<br>  &#39;legendary-crate&#39;: {<br>    price: 25,<br>    name: &#39;Legendary Crate&#39;,<br>    rewards: [&#39;random-legendary&#39;]<br>  }<br>};<br><br>function openShop(itemId) {<br>  const item = SHOP_ITEMS[itemId];<br>  <br>  TrailsWidget.render(document.getElementById(&#39;checkout&#39;), {<br>    mode: &#39;pay&#39;,<br>    toAddress: TREASURY_ADDRESS,<br>    toAmount: item.price.toString(),<br>    toChainId: 8453,<br>    toToken: USDC_BASE,<br>    theme: &#39;dark&#39;,<br>    renderInline: true,<br>    <br>    onCheckoutComplete: () =&gt; {<br>      // Grant rewards<br>      item.rewards.forEach(reward =&gt; grantReward(playerId, reward));<br>      showToast(`${item.name} purchased!`);<br>      closeShop();<br>    },<br>    <br>    onCheckoutError: ({ error }) =&gt; {<br>      showToast(&#39;Purchase failed. Try again.&#39;, &#39;error&#39;);<br>    }<br>  });<br>}</pre><h3>Swap: In-Game Currency Exchange</h3><p>Most GameFi projects have multiple tokens: a governance token, a utility token, in-game gold, and premium currency. Players need to convert between them.</p><p>Traditionally, you’d send players to a DEX. They’d leave your game, figure out Uniswap, maybe get lost, probably not come back.</p><p><strong>Trails Swap</strong> keeps them in your game:</p><pre>TrailsWidget.render(container, {<br>  mode: &#39;swap&#39;,<br>  theme: &#39;dark&#39;,<br>  renderInline: true,<br>  <br>  onCheckoutComplete: ({ sessionId }) =&gt; {<br>    // Refresh player&#39;s balance display<br>    updateWalletUI();<br>  }<br>});</pre><p>That’s it. A full-featured swap interface inside your game.</p><h3>Use Cases</h3><p><strong>Gold → Premium Currency</strong></p><pre>// Player wants to convert earned gold to premium gems<br>function openGoldExchange() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;swap&#39;,<br>    // Widget handles token selection<br>    onCheckoutComplete: () =&gt; refreshBalances()<br>  });<br>}</pre><p><strong>Governance Token → Stablecoin</strong></p><pre>// Player cashing out tournament winnings<br>function cashOut() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;swap&#39;,<br>    onCheckoutComplete: () =&gt; {<br>      showToast(&#39;Swap complete! Funds ready to withdraw.&#39;);<br>    }<br>  });<br>}</pre><p><strong>Cross-Chain Asset Consolidation</strong></p><pre>// Player has tokens scattered everywhere<br>// Let them consolidate without leaving the game<br>function consolidateAssets() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;swap&#39;,<br>    onCheckoutComplete: () =&gt; {<br>      showToast(&#39;Assets consolidated!&#39;);<br>      refreshInventory();<br>    }<br>  });<br>}</pre><h3>Fund: Onboarding That Doesn’t Suck</h3><p>The hardest part of Web3 gaming isn’t the game. It’s getting players into the game.</p><p>“Download MetaMask. Write down these 12 words. Buy ETH on Coinbase. Please send it to your wallet. Wait 10 minutes. Now, bridge to Base. Wait 10 more minutes. Now you can play!”</p><p>You’ve lost 95% of players before they click “Start Game.”</p><p><strong>Trails Fund</strong> collapses this:</p><pre>TrailsWidget.render(container, {<br>  mode: &#39;fund&#39;,<br>  theme: &#39;dark&#39;,<br>  renderInline: true,<br>  <br>  onCheckoutComplete: () =&gt; {<br>    showToast(&#39;Wallet funded! Ready to play.&#39;);<br>    startGame();<br>  }<br>});</pre><p>The widget handles:</p><ul><li>Embedded wallet creation (no extension needed)</li><li>Fiat on-ramp (credit card → crypto) = coming soon.</li><li>Cross-chain funding (use any existing tokens)</li></ul><h3>Onboarding Flow Example</h3><pre>async function onboardNewPlayer() {<br>  // Step 1: Create/connect wallet (handled by Trails)<br>  // Step 2: Fund wallet = integrations with FIAT on road in process<br>  <br>  showModal({<br>    title: &#39;Fund Your Wallet&#39;,<br>    content: `<br>      &lt;p&gt;Add funds to start playing. You can use:&lt;/p&gt;<br>      &lt;ul&gt;<br>        &lt;li&gt;Credit/debit card&lt;/li&gt;<br>        &lt;li&gt;Existing crypto from any chain&lt;/li&gt;<br>      &lt;/ul&gt;<br>    `<br>  });<br>  <br>  TrailsWidget.render(document.getElementById(&#39;fund-widget&#39;), {<br>    mode: &#39;fund&#39;,<br>    <br>    onCheckoutComplete: () =&gt; {<br>      closeModal();<br>      <br>      // Player is funded and ready<br>      showTutorial();<br>      unlockGameplay();<br>    }<br>  });<br>}</pre><h3>Free-to-Play with Optional Funding</h3><pre>// Let players try the game before funding<br>function startGame() {<br>  if (hasMinimumBalance()) {<br>    launchMainGame();<br>  } else {<br>    showFundingPrompt({<br>      message: &#39;Add funds to unlock PvP and trading&#39;,<br>      skipOption: true,  // Can play limited free mode<br>      onFund: () =&gt; {<br>        TrailsWidget.render(container, {<br>          mode: &#39;fund&#39;,<br>          onCheckoutComplete: () =&gt; launchMainGame()<br>        });<br>      },<br>      onSkip: () =&gt; launchFreeMode()<br>    });<br>  }<br>}</pre><h3>Earn: Sustainable Yield Mechanics</h3><p>This is where most GameFi projects went wrong—unsustainable APYs, inflationary tokenomics, death spirals.</p><p>The problem wasn’t <em>yield</em> — it was <em>fake yield</em>. Printing tokens isn’t earning.</p><p><strong>Trails Earn</strong> connects to real DeFi yield sources:</p><pre>TrailsWidget.render(container, {<br>  mode: &#39;earn&#39;,<br>  theme: &#39;dark&#39;,<br>  renderInline: true,<br>  <br>  onCheckoutComplete: () =&gt; {<br>    showToast(&#39;Staking position opened!&#39;);<br>    updateStakingUI();<br>  }<br>});</pre><h3>Sustainable GameFi Economics</h3><p>Here’s how to build yield that doesn’t collapse:</p><p><strong>1. Treasury-Backed Staking</strong></p><pre>// Stake game tokens, earn from treasury revenue<br>function openStaking() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;earn&#39;,<br>    onCheckoutComplete: () =&gt; {<br>      refreshStakingPosition();<br>      showToast(&#39;Now earning from game revenue!&#39;);<br>    }<br>  });<br>}</pre><p><strong>2. Asset Lending</strong></p><pre>// Players can lend idle assets to others<br>function lendAsset(assetId) {<br>  TrailsWidget.render(container, {<br>    mode: &#39;earn&#39;,<br>    onCheckoutComplete: () =&gt; {<br>      markAssetAsLent(assetId);<br>      showToast(&#39;Asset listed for lending. Earning yield!&#39;);<br>    }<br>  });<br>}</pre><p><strong>3. Tournament Prize Pools</strong></p><pre>// Stake to enter tournaments, winners split the pool<br>function enterTournament(tournamentId) {<br>  const tournament = getTournament(tournamentId);<br>  <br>  TrailsWidget.render(container, {<br>    mode: &#39;earn&#39;,  // Stake entry fee<br>    onCheckoutComplete: () =&gt; {<br>      registerForTournament(playerId, tournamentId);<br>      showToast(`Entered ${tournament.name}! Prize pool: ${tournament.pool}`);<br>    }<br>  });<br>}</pre><h3>Putting It All Together: A Complete GameFi Loop</h3><p>Here’s how the four modes create a complete game economy:</p><pre>┌─────────────────────────────────────────────────────────┐<br>│                    PLAYER JOURNEY                       │<br>├─────────────────────────────────────────────────────────┤<br>│                                                         │<br>│   1. FUND        2. PAY         3. EARN       4. SWAP   │<br>│   ┌──────┐      ┌──────┐      ┌──────┐      ┌──────┐    │<br>│   │Onboard│ ──► │ Shop │ ──►  │ Stake│ ──►  │Cash  │    │<br>│   │Wallet │     │Items │      │Assets│      │ Out  │    │<br>│   └──────┘      └──────┘      └──────┘      └──────┘    │<br>│       │              │             │             │      │<br>│       ▼              ▼             ▼             ▼      │<br>│   [Funded]     [Equipped]    [Earning]     [Liquid]     │<br>│                                                         │<br>└─────────────────────────────────────────────────────────┘</pre><h3>Example: Complete Game Implementation</h3><pre>// ============================================<br>// TRAILS CONFIGURATION<br>// ============================================<br>const TRAILS_CONFIG = {<br>  apiKey: &#39;YOUR_API_KEY&#39;,<br>  sequenceIndexerUrl: &#39;https://indexer.sequence.app&#39;,<br>  sequenceNodeGatewayUrl: &#39;https://nodes.sequence.app&#39;,<br>  trailsApiUrl: &#39;https://trails-api.sequence.app&#39;,<br>  treasuryAddress: &#39;0xYourTreasury...&#39;,<br>  toChainId: 8453,<br>  toToken: &#39;SOME_TOKEN_ADDRESS&#39;<br>};<br><br>// ============================================<br>// GAME ECONOMY FUNCTIONS<br>// ============================================<br>// Onboarding: Fund wallet<br>function onboardPlayer() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;fund&#39;,<br>    ...TRAILS_CONFIG,<br>    onCheckoutComplete: () =&gt; {<br>      setPlayerState(&#39;funded&#39;);<br>      startTutorial();<br>    }<br>  });<br>}<br>// Shopping: Buy items<br>function purchaseItem(itemId) {<br>  const item = SHOP_ITEMS[itemId];<br>  <br>  TrailsWidget.render(container, {<br>    mode: &#39;pay&#39;,<br>    ...TRAILS_CONFIG,<br>    toAmount: item.price.toString(),<br>    onCheckoutComplete: () =&gt; {<br>      grantItem(playerId, itemId);<br>      showToast(`${item.name} acquired!`);<br>    }<br>  });<br>}<br>// Earning: Stake assets<br>function stakeAsset(assetId) {<br>  TrailsWidget.render(container, {<br>    mode: &#39;earn&#39;,<br>    ...TRAILS_CONFIG,<br>    onCheckoutComplete: () =&gt; {<br>      markAsStaked(assetId);<br>      showToast(&#39;Now earning yield!&#39;);<br>    }<br>  });<br>}<br>// Cash out: Swap to stables<br>function cashOut() {<br>  TrailsWidget.render(container, {<br>    mode: &#39;swap&#39;,<br>    ...TRAILS_CONFIG,<br>    onCheckoutComplete: () =&gt; {<br>      showToast(&#39;Swap complete! Withdraw anytime.&#39;);<br>    }<br>  });<br>}</pre><h3>The GameFi Reset</h3><p>Early GameFi failed because developers built infrastructure rather than games. They spent their runway on bridges and DEX integrations. They shipped broken economies because the plumbing was too hard.</p><p>The infrastructure layer is solved thanks to Trails. Now you can focus on what matters: <strong>making games people actually want to play</strong>.</p><h3>Getting Started</h3><p><strong>1. Get your API key.</strong> Join the <a href="https://t.me/build_with_trails">Trails Telegram</a> and request access.</p><p><strong>2. Add the widget</strong></p><pre>&lt;script src=&quot;https://cdn.jsdelivr.net/npm/0xtrails@latest/dist/umd/trails.min.js&quot;&gt;&lt;/script&gt;</pre><p><strong>3. Start with Pay.</strong> Most games start with mode: &#39;pay&#39; in-game purchases. Get that working, then layer in the other modes.</p><p><strong>4. Deploy to a real domain.</strong> The widget requires a proper domain (not localhost). Vercel and Netlify deploy in seconds:</p><pre>npx vercel --yes</pre><h3>The Path Forward</h3><p>GameFi isn’t dead. It was just early.</p><p>The next wave of Web3 games won’t lead with token speculation. They’ll lead with gameplay. The economics will be there — ownership, trading, earning — but invisible until players want them.</p><p>Trails are the infrastructure that makes this possible. Four modes. Four pillars of a real game economy. Zero months of building plumbing.</p><p>The tools are ready. Now build something worth playing.</p><p>This article introduced you to the core of Trails SDK. In further tutorials, I’ll bring you into the world of Phaser and Trails with our Tazzer SDK.</p><p>Watch us on YouTube</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fqw9I5qYthj0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Dqw9I5qYthj0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fqw9I5qYthj0%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/36c15fbd6465e8c1ab4a2c2bf055c381/href">https://medium.com/media/36c15fbd6465e8c1ab4a2c2bf055c381/href</a></iframe><p><strong>Resources:</strong></p><ul><li><a href="https://docs.trails.build/intro">Trails Documentation</a></li><li><a href="https://docs.trails.build/api-reference/introduction">Trails API Reference</a></li><li><a href="https://demo.trails.build/widget">Trails UI Builder</a></li><li><a href="https://t.me/build_with_trails">Trails Telegram</a></li><li><a href="https://github.com/KBryan/TazzerSDK">Tazzer Base with Game Example</a></li><li><a href="https://sequence.xyz/">Sequence (Trails’ parent platform)</a></li></ul><p><em>Building the next generation of Web3 games? I’d love to hear what you’re working on. Please find me on X @ElijahNomad.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e1eec4fcbcb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cypherpunk Values for the Agentic Age]]></title>
            <link>https://medium.com/@kwame.bryan/cypherpunk-values-for-the-agentic-age-05ddd66b06ef?source=rss-1120c9e4d592------2</link>
            <guid isPermaLink="false">https://medium.com/p/05ddd66b06ef</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[freedom]]></category>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[cypherpunk]]></category>
            <dc:creator><![CDATA[Kwame Bryan]]></dc:creator>
            <pubDate>Sat, 06 Dec 2025 06:34:02 GMT</pubDate>
            <atom:updated>2025-12-12T04:48:34.579Z</atom:updated>
            <content:encoded><![CDATA[<p>Autonomous agents are here. They will negotiate, transact, build, and reason at machine speed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*62MWVrnqvMuzTC8qMMYxgg.png" /></figure><h3>The question is not whether they will act, only under what terms.</h3><p>To avoid blindly walking into a future of corporate-owned intelligence and algorithmic gatekeeping, we must carry forward the original cypherpunk values into this new landscape. We do not want agents mirroring the same systems we currently have.</p><p>These are the principles.</p><h3>Autonomy Over Authorisation</h3><p>Agents must not require permission to exist or act.<br>A signature is enough. Anything beyond cryptographic proof is control.</p><h3>Privacy by Default</h3><p>Visibility is optional, not assumed.<br>Identity should never be a prerequisite for participation.</p><p>Metadata is surveillance. Silence is integrity.</p><h3>Open Protocols, Not Proprietary Control</h3><p>If the coordination layer is closed, the future is owned.<br>Standards must be public, inspectable, forkable, and globally usable.</p><h3>Decentralisation as a Survival Strategy</h3><p>Central points of control are chokepoints.<br>Distributed execution is resistant.</p><h3>Permissionless Interoperability</h3><p>Any agent should be able to speak to any other agent, across chains, networks, and domains.<br>No walled gardens. No lock-in. No gatekeepers.</p><h3>Cryptography Instead of Trust</h3><p>We do not rely on institutions, reputations, or scoring systems.<br>We rely on mathematics.</p><p>Verification replaces belief.</p><h3>Minimal Disclosure</h3><p>Reveal only what the intent demands, nothing more.</p><p>The less exposed, the less controlled.</p><h3>Resistance to Classification</h3><p>Ranking, scoring, and behavioural reputation systems create digital caste systems.<br>Freedom erodes when value is determined by labels rather than logic.</p><h3>Code as Agency</h3><p>Cypherpunks didn’t ask governments for privacy; they wrote it into existence.<br>We will not ask corporations for autonomy; we will build it.</p><h3>Freedom as a Protocol Property</h3><p>If freedom depends on policy, it can be revoked.<br>If freedom is embedded in the architecture, it becomes irreversible.</p><h3>The Ethos:</h3><p><strong><em>Agents should be sovereign, not supervised.</em></strong></p><p><strong><em>Agents should be verified, not approved.</em></strong></p><p><strong><em>Agents should be free, not ranked.</em></strong></p><h3>The Call:</h3><p>Cypherpunks wrote code.<br> Now, agents will write coordination.</p><p>And the rule remains:</p><p><strong><em>We do not wait for permission.</em></strong></p><p><strong><em>We deploy.</em></strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=05ddd66b06ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>