Imagine that a customer tells an AI assistant, “Find me running shoes under $120 and buy the best pair.” The assistant searches a few stores, compares prices and reviews, adds a pair to a cart, and checks out. The customer approves a single prompt. No one browses your site.
That’s agentic commerce, and it’s already moving from experiment to habit. In September 2026, Akamai saw an average of 2.2 billion AI bot requests a day across commerce sites.
For merchants, that’s a new channel with real buyers in it. But it’s a channel with a built-in problem.
Many shopping agents work by driving a browser the way a person would, often with the customer’s own logged-in session. To your site, that looks like an ordinary visit. We call these “silent agents,” and they’re very hard to handle. A legitimate assistant buying sneakers for a real customer and a reseller bot imitating a real customer can look almost identical.
The result introduces friction for shoppers and merchants alike:
Retailers that treat all automation as hostile turn away real customers. Shoppers are already reporting that their agents can’t finish purchases on sites that block them.
Retailers that let everything through give unknown automation the same access as a customer’s trusted assistant.
Our research found that commerce organizations put more than 90% of AI bot activity into monitor-only mode and let roughly three-quarters of the rest through without restriction. Most were watching agentic traffic, not governing it.
Agentic commerce only works if merchants can say “yes” to the right agents. That requires a way for an agent to prove its identity. Commerce organizations should make verification the path to yes.
Skyfire, the identity and trust layer for AI agents, built Know Your Agent (KYA) for exactly this scenario. KYA is an open protocol for verifying what an agent is and who it acts for. It’s the agent version of Know Your Customer (KYC), the identity checks banks run before they open an account.
Here’s how it works, using an example customer:
The customer gets verified. A person or business is verified once by Skyfire, and that verified identity carries to every agent they authorize.
The agent gets a token. When the shopping agent needs to reach your site, it generates a KYA token. A KYA token goes beyond a login. Authentication tells you that an agent has a credential. A KYA token tells you who stands behind it. It’s a signed credential, in a standard format (a JSON Web Token), that carries three verified facts:
The user: The person or business the agent is shopping for, whose identity has been checked
The operator: The company that built and runs the agent, such as the AI assistant or platform the customer is using
The agent: The specific agent making this request
The agent presents the token. It adds the token to its request as an ordinary HTTP header, so your site doesn’t need to change.
The Akamai edge checks the signature. Skyfire signs the token. Akamai checks the signature at the edge, and any forged, altered, or expired tokens fail.
You apply your policy. Once the token checks out, your policy decides what that agent can do, based on what the token carries.
Tokens can be limited to contain the fields that a site actually needs, so a verified agent doesn’t have to reveal everything about its owner.
KYA also extends to payments. With KYAPay, the same token can carry payment authorization, such as a spending cap for a specific purchase, so identity and payment travel together. That matters in agentic commerce, where “Who is this agent?” and “What is it allowed to spend?” are really a single question.
Our recent blog post warns against exemptions based on a pattern: a recognizable mix of headers and behavior that a known agent tends to produce. Anything that imitates the pattern inherits the exemption, and the traffic most eager to imitate a shopping agent is the traffic you want least at checkout.
A KYA token works differently because it carries proof, based on three components:
Identity: Who the agent is. The agent operator defines this ahead of time, when it registers the agent.
Attestation: Confirmation of who stands behind the agent. Skyfire verifies the operator and the user the agent acts for (KYC for individual customers, KYB for businesses) and embeds that result in the token.
Authentication at the edge: A cryptographic check at runtime. When the agent presents its token, Akamai verifies it as the request arrives. A passing check confirms the identity of the agent as well as the user it’s acting for.
Copying how a verified agent behaves doesn’t get you past any of those actions. That lets you grant access to a verified party instead of to a pattern, which is what “make verification the path to yes” looks like in practice.
Selective action means setting policy by endpoint, not by site. In agentic commerce, that maps neatly onto the three steps a purchase takes:
Discovery and comparison
Cart and checkout
Login and account changes
An agent reading product pages and prices for a customer is doing what browsers have always done, and it’s how your products get found by AI assistants. Keep this door open. A verified agent gets the same access, plus you know who it represents.
This is where money and inventory move. Every request is still scored for automation risk, and a verified agent can have its own policy here, written for a known party rather than a guess.
Here the question is whether the session belongs to the account holder and whether the action fits that account’s normal behavior. A verified agent identity and attested user gives you far more to work with than a browser fingerprint.
Silent agents aren’t treated as guilty by default. Some are legitimate assistants whose builders haven’t adopted cryptographic verification yet. They keep going through behavioral scoring, which is why some legitimate agents still get stopped at checkout. The difference is that there’s now a clear way out: Verify, and get a policy written for you instead of inferred about you.
Akamai Bot & Agent Control solutions natively support Skyfire KYA tokens. Merchants can recognize verified shopping agents and enforce access policy at the edge using what they already run. There’s nothing to install and no integration to build.
And it’s already running. A single financial data provider has generated 2.5 million KYA-powered agentic transactions on Akamai-protected sites. That’s verified agent activity at real volume, from one participant.
A purchase made by an agent passes through fraud screening, payment authorization, and more. Akamai makes the first decision for every request; that is, whether this agent may attempt this transaction at all.
A verified agent that passes carries its identity with it, so every downstream check starts from a known party instead of a guess.
If you’re a merchant: Agents verified with KYA are part of Akamai’s verified bot directory, and they’re handled according to the policy you’ve already defined. To get more from agentic traffic, set a policy for verified agents at cart and checkout, so assistants buying for real customers can complete the purchase. Everything else is treated the same as it is today.
If you build agents: Don’t wait to be blocked. Register your agent with Skyfire to get verified, then present a KYA token with each request so your traffic is recognized.
To talk through your agent traffic and how to welcome the right agents, contact an Akamai expert.
© 2026 Akamai Technologies
