How Agents Become Economic Participants: The Six Systems Agentic Commerce Needs to Scale

‍Key takeaways

• The demand for agentic commerce is here and growing fast: AI chatbot referral sessions to Shopify stores grew more than 8x year over year in the first quarter of 2026.¹
• Six systems need to mature in order to support agentic commerce at scale: payment methods, checkout execution, product data, identity, guardrails and intent, and recourse.
• Crossmint provides solutions for agentic payments and agentic checkout; a unified agentic payment protocol that supports stablecoin and card (Visa, Mastercard) payments, and agentic checkout support for 5.6M Shopify stores.
• Crossmint is partnering with others in the agentic ecosystem to build all the systems necessary to facilitate agentic commerce.

Commerce, from everyday purchases to complex business transactions, is going to be handled autonomously by agents. That shift makes trillions of dollars of economic activity more efficient and puts the full power of global commerce in reach of anyone with an agent.

The demand is starting. AI chatbot referral sessions to Shopify stores grew more than 8x year over year in the first quarter of 2026, and orders from those sessions grew nearly 13x.¹ However, referral demand isn't translating into agents actually participating in ecommerce transactions: research through mid-2026 finds purchasing still overwhelmingly human-driven.²
‍

The gap is not caused by one missing feature. Agent purchasing depends on six systems: payment methods, checkout execution, product data, identity, guardrails and intent, and recourse. Each is at a different stage of development, and each has to mature before agents transact at scale. The rest of this piece covers what each system is, where it stands today, what is missing, and what has to happen next.

1. Payment methods: money in a form an agent can hold

Before an agent can buy anything, it needs access to money in a form it can actually use. Most people pay with a mix of methods: credit and debit cards, wallet buttons, local rails, bank transfer. Almost none of them have a native way for an agent to use them without either leaking card data into a model's context or the developer’s servers. Building an agent that stores raw card details violates PCI requirements and exposes the card number every time the agent goes to use it.

Card networks have built solutions for this. Visa Intelligent Commerce and Mastercard Agent Pay issue agent-specific credentials tied back to the cardholder, so an agent can transact on a card without ever seeing the underlying number. Like the other networks, Amex has a program, ACE, on the way. 

Stablecoins are gaining adoption as a second path. The agent holds funds in a wallet and spends them directly, with no issuer in the loop and no card number to protect. The x402 protocol is how most of these payments settle today: when an agent requests something that costs money, the seller's server responds with a price and the agent pays from its wallet. A network facilitator verifies and settles the transaction onchain in seconds, allowing the server to instantly deliver the requested data or service.

Crossmint supports both methods through a single platform covering stablecoin and card payments. Acceptance for stablecoins and agentic card credentials is small but growing and will continue to grow as agent adoption increases for individuals and businesses. Over time, I expect every payments company to create their own method for delegated access to agents.

2. Checkout execution: completing the purchase

Having money is not the same as being able to spend it. Think about buying something online. You land on the product page, pick the size and color, add it to your cart, open the cart, enter a shipping address, enter payment details, clear whatever verification step the store puts in front of you, and click place order. Every one of those steps is a page built for a person to read and click through.

For agents, two approaches to executing checkouts exist today.

The first is agentic commerce protocols such as UCP, ACP, or x402. These let a merchant expose a purchase path built for agents, so the agent calls an API instead of clicking through pages. When available, it’s seamless. The problem is coverage: fewer than one in a thousand websites offer a public API at all, and the ones that do expose a fraction of what a person can do on the site.³

The second approach, particularly relevant for ecommerce, is browser automation, aka computer use. The agent drives a real browser the way a person would: it loads the page, reads what is on the screen, clicks buttons, and fills in fields, deciding each next action as it goes. It is the only approach that works on a store that has done nothing to prepare for agents, which today is nearly all of them. 

What makes browser automation hard?

• Every store is different. Checkout flows vary by platform, theme, and configuration, so an agent that completes a purchase on one store can fail on the next. Cart drawers and overlays appear where the agent expects a button.
• Stores reject automated buyers. Bot detection and captchas turn away agent sessions, and some payment buttons refuse automated checkout outright. Others offer no guest checkout at all, so the agent needs account credentials it has no safe way to hold.
• Some steps still require a person. One-time passcodes and 3DS verification prompts stop the checkout and wait for a human to respond.
• A completed purchase is hard to prove. Merchants send the receipt to a customer's email inbox rather than back to the agent, so the agent cannot always confirm what it bought.

Cost is the other constraint. An agent driving a browser reads the page, sends it to a model, and asks what to do next, then repeats that for every step of the checkout. A single purchase can take dozens of round trips, each one carrying a full page of context, and any step that fails has to be retried. That is how one checkout attempt reaches tens of dollars in model tokens.

Even as the protocols improve and more merchants adopt them, universal coverage is years away. Browser automation has to work reliably in the meantime, which means resolving these failure modes and bringing the cost of a checkout down from dollars to cents.

3. Product data: knowing what the agent is buying

An agent buys from what it can read. Product data, price, variants, availability: if any of these are stale or wrong, a flawless checkout buys the wrong thing at the wrong price. If the data is missing entirely, the checkout buys you nothing at all, because the agent never finds the product.

The data itself is getting better. Merchants are publishing product information in formats machines can read, and it is already changing how people shop: AI-referred sessions convert nearly 50% better than organic search when they start on a product page, and they carry 14% higher average order values.¹ Shopify's Catalog API exposes structured, agent-readable product data across its merchant base, and independent players like Catalog or Channel3 are building catalog layers for agents that need coverage beyond any single platform.

But catalogs are fragmented. Stitching together all the places that an agent might need to search requires access to many different data sources and making it all readable to the agent. Even then, agents will need lots of customization before they can become adept at the nuanced task of identifying the right products for human preferences. 

This system matures when an agent can start from what a person actually wants, read verified catalog data to find and compare the options, perhaps even buying several items from a merchant in a single order.

4. Identity: the merchant decides whether the agent can buy

An agent shopping on a user's behalf carries the user's permission, but not the merchant's. Establishing the identity of agents to merchants is also vital to creating the trust necessary to facilitate commerce.

Today, a returning human buyer carries cookies, a device fingerprint, and a login the store remembers. An agent that arrives from a fresh IP address and authenticates from scratch on every purchase produces the same signature as an attack, and anti-bot systems treat it as one. When a merchant requires an account, the user has no safe way to hand over credentials without exposing them to the agent platform.

How do you solve this? Work on agent identity is happening at three layers:

At the network layer, Cloudflare's Web Bot Auth lets an agent cryptographically sign its requests so a site can identify it as a known bot rather than inferring from traffic patterns. Cloudflare has been working with payments companies to make that signal usable at checkout.⁴

At the payment layer, the card networks are issuing the agent credentials described earlier. Visa's Trusted Agent Protocol authenticates an agent during the transaction itself, and Mastercard's Agent Pay pairs agent purchasing with fraud controls.

At the identity layer, companies like Socure and Baselayer are building tools for KYA (Know Your Agent), which identify who the agent works for and what they allow the agent to do.

While the three layers above establish who an agent is acting on behalf of, there are open questions as to whether merchants should care how the agent was built: Which AI model is making the decisions for the agent? What software sits around the model deciding what it is allowed to do? 

Additionally, merchants want to track a returning customer the same way they track humans: past orders, chargebacks, suspicious activity. 

Underneath all of it is a (temporary) incentive alignment problem. An agent that cryptographically identifies itself as a bot hands every site an easy way to reject it. Verification only pays off when verified agents get better treatment than anonymous ones. Today agents are better off looking like humans and hiding the fact that they’re agents.

A mature identity layer answers all of the above: who the agent works for, what it is built on, how it has behaved at other merchants, and a way for a user to hand over account credentials without the developer seeing them. It also has to be worth using, so a verified agent moves through checkout more easily than anonymous traffic.

5. Guardrails and Intent: making sure the agent buys the right thing with the right authority

Keeping an agent honest happens in three phases. Before the purchase, there are guardrails set ahead of time: spending caps, budgets, merchant allowlists. During the purchase, the agent has to translate a human's ambiguous intent into the right action. And after, someone has to verify the agent actually did what was asked, and correct it if not.

The first phase is relatively easy. "The agent can't spend more than $100" or "only buy from Target" are solved problems. The hard part is the middle: intent. Imagine you ask for premium coffee and get a bag of Dunkin'Donuts. The agent stayed inside every guardrail but still failed (sorry to New Englanders, Dunkin is great.) 

Nobody disputes that this problem needs solving. The gap isn't technical. Its adoption. Many companies are building guardrail, verification, and intent systems, but there's no clear path for how any of it makes its way into the world. Will merchants and payments companies coalesce around an open standard? Will everyone build their own proprietary version? Will a patchwork of standards need to be made interoperable? 

In the meantime, lots of companies are attacking pieces of this. One example of an open-source approach is the Verifiable Intent spec, which treats intent as a cryptographic problem: the user signs constraints such as amount limits, merchant allowlists, and budget caps, and the agent later proves it acted inside them.

When this matures, agents arrive at satisfactory outcomes far more often, because human intent becomes legible to them. When an agent does screw up, there's a clear trail of what went wrong, so the failure can be diagnosed and the agent trained, not just retried. And agents stop guessing on ambiguity: an unclear request gets clarified before money moves, not after.

6. Recourse: when the agent gets it wrong, someone makes it right

Guardrails reduce mistakes, they do not eliminate them. If there’s a wrong size or duplicate order, someone pays for each mistake. Today there is no clear path to resolving which actor is at fault. 

Cards have that process today. A cardholder disputes a charge, the issuer reverses it, and the merchant absorbs the cost. Deciding those disputes depends on evidence that a specific person made a specific purchase: 3DS authentication results, the device, the IP address, the location. How evidence is collected, shared, and disputes resolved in a world where agents become economic actors has yet to be defined. 

Many are attempting to answer this question. For example, Visa's Trusted Agent Protocol is designed to give merchants a cryptographic record that the consumer authorized the agent, so there is something to present when a purchase is disputed. They are also looking to add dispute categories specific to agents and shift liability to the agent's operator when the agent exceeded what it was authorized to do.

Stablecoin payments have no equivalent at all. A transfer settles and stays settled, so any recourse has to be built outside the payment.

Underneath both is the principal-agent problem, where the party taking the action has different information and incentives than the party whose money is at stake. Signed mandates, verifiable intent, and guardrails reduce how often it goes wrong, and a new wave of companies is forming to price the risk that remains. Agentic transactions will soon come with insurance policies. 

All of these pieces will build trust in agents as economic actors. ‍

Building the rest of the stack

Crossmint is developing solutions and partnering with the broader agentic ecosystem to deliver the right systems to facilitate agentic commerce. Our Agentic Payments infrastructure gives agents wallets, stablecoin payments and card access. 

‍
If you're building in agentic payments, reach out here to chat with us.

‍

Sources

1. Shopify, AI-referred traffic and conversion data, Q1 2026: https://www.shopify.com/enterprise/blog/ai-search-insights

2. Forrester, "The State of Agentic Commerce in Mid-2026," July 2026: https://www.forrester.com/blogs/the-state-of-agentic-commerce-in-mid-2026/

3. Hark, "Introducing Hark Handoff," August 2026: https://hark.com/articles/introducing-hark-handoff

4. Cloudflare, Web Bot Auth and agentic payments collaboration, October 2025

‍