The Architecture of Agentic Commerce

Software has always built more software. Now, software buys software.

Most modern AI systems introduce some level of Agentic Commerce. The AI, acting as an agent for the user, buys tokens, pays for third party applications, and even has the option to interact with financial systems. Hardware devices have a role to play in building trust when it comes to these agentic systems and the reason is because of the architecture of how they are built.

Previous efforts on the internet have gone through iterations of building human identity with usernames, passwords, accounts, and, dreadfully, subscriptions. New trends are emerging that bypass the identity crisis entirely and are being tooled for autonomous economic activity. Autonomous commerce requires trust in heterogeneous payments, identity, authorization systems to become interoperable instead of separate products.

I think the interesting question becomes not just how do organizations come together to build those standards; I remember my pops talking about the W3C and the many other standards groups, particularly about how apparently Sir Tim Berners-Lee was a bit of a Diva*, but mostly because they established HTTP, OAuth, and XML, while conventions like RSS and REST gave developers shared ways to build. Industry had to agree on common protocols or the web would fracture into incompatible ecosystems. The web did not scale because one company built the best browser. It scaled because competitors agreed on enough common protocols that innovation could happen above them. Agentic commerce appears to be reaching a similar moment. MCP, x402, stablecoins, authorization frameworks and identity standards are all evolving independently and they will become transformative if they converge into a shared language.

Coinbase introduced Agentic Wallets in February 2026, MetaMask has one, Ledger has an Agent Stack. Many large crypto houses either have them or are similarly interested in building them out. In many ways this mirrors the wider world of the new ecommerce following similar trends in online shopping wallets, social media payment methods, banking, trading and gambling platforms. Still, differences are starting to emerge between the philosophies of the wallets. At first glance they appear to be solving the same problem. They aren't. Those differences come down to this:

“When is human intervention required?”

Programmable wallets delegate in advance, they are customized by people and then largely hand off the authority to act to the agent. The other approach is centered more in the self-custody loop, where policy-driven wallets delegate execution and outline constraints requiring human approval for sensitive activities.

The programmable wallet puts heavy emphasis on SDKs, APIs, x402 and MCP, all being assembled into the same infrastructure stack, creating a digital superstructure. This philosophy goes beyond crypto wallets, the blockchain becomes the settlement layer when payments are necessary, but they build the authority into the wallets to approve the on-chain activity unseen by human eyes. Alternatively, emphasizing protocol allowlists, transaction simulation, revocable permissions, and most crucially human approval bends the policy-driven wallet more towards a consumer UX.

In the hardware wallet world, you are the authority. It asks if you are willing to sign this transaction. If software does become the economic actor, is self-custody still about controlling private keys, or is it more about controlling delegated authority? I've postulated previously that there is a signature that happens before a transaction even begins to be drawn up. If I delegate my willingness to buy, my trust in the counterparty, the timing of the decision and some measure of signing authority to my agent, where does my consent actually occur?