# How Should Businesses Secure Agentic Commerce in 2026?

Paige Thornton · September 30, 2026

> What Agentic Commerce Security Actually Means Agentic commerce security is the set of technical, financial, contractual, and operational controls...

## What Agentic Commerce Security Actually Means

Agentic commerce security is the set of technical, financial, contractual, and operational controls needed when an AI shopping agent can search for products, compare merchants, negotiate terms, place an order, authorize payment, and initiate delivery without a person approving each action. The risk is not limited to chatbot output: an agent may execute browser or API actions inside systems that were never designed for machine customers. A conventional checkout protects the buyer from some fraud, but it does not automatically establish that an agent had permission to buy, selected the intended item, obeyed a merchant's restrictions, or presented an authentic receipt.

**Also worth reading:** [How Can Businesses Control Agentic AI Costs Without Slowing Deployment?](https://zdnetinside.com/knowledge/how_can_businesses_control_agentic_ai_costs_without_slowing_deployment.php) · [What Are AI Agent Control Layers and How Should Businesses Deploy Them in 2026?](https://zdnetinside.com/knowledge/what_are_ai_agent_control_layers_and_how_should_businesses_deploy_them_in_2026.php) · [SMB AI Readiness Checklist: What Should Small Businesses Test Before Adoption?](https://zdnetinside.com/knowledge/smb_ai_readiness_checklist_what_should_small_businesses_test_before_adoption.php)

By 30 September 2026, agentic commerce is moving from product demonstrations toward payment rails, merchant controls, and delegated spending. Antom announced an agentic payment solution in September 2025, while IDEMIA framed secure transactions as a way to open agentic commerce to additional payment schemes. Mastercard, Flybits, and Rogers Bank also established a Canadian benchmark centered on secure, consumer-controlled agentic commerce. These developments do not prove that the market has settled on one identity, authorization, or liability model, but they show that security must span the entire transaction rather than merely adding a disclaimer to an AI shopping interface.

The practical objective is bounded agency: the agent should do what the customer authorized, no more and no less, while every consequential action remains attributable, reviewable, and revocable. That requires stronger controls than simply using a reputable large language model or relying on HTTPS. It also means security cannot be treated as an agent-specific add-on; it must connect AI behavior to payment credentials, inventory systems, merchant policies, access controls, and existing ERP backends.

## The Main Threats and Failure Modes

The central threat is compromised agency. Prompt injection can enter an agent through a web page, product description, email, invoice, customer-support message, or structured merchant feed. For example, hidden instructions might tell a shopping agent to ignore its budget, substitute a higher-priced product, disclose account data, or route payment to an attacker. Traditional application security testing may miss this risk because the harmful instruction changes the model's interpretation of legitimate content rather than exploiting a conventional software vulnerability.

Identity and delegation failures are equally important. A customer needs a durable way to identify an agent without exposing reusable payment credentials, and a merchant needs to distinguish an authorized buyer from an impersonator. Delegation should specify an amount ceiling, merchant or category scope, expiration time, and actions requiring human approval. A natural-language instruction such as “buy the best laptop under $2,000” is useful intent, but it is a poor security policy because “best,” price accuracy, inventory status, shipping terms, and tax can all change between planning and checkout.

Agent shopping also creates confused-deputy and excess-authority risks. If the agent has broad access to a customer's account, a manipulated tool call may retrieve sensitive information or invoke unrelated workflows. Conversely, an overly restricted agent may be unable to complete purchases safely, leading developers to weaken controls to make the demo work. Secure design therefore uses least privilege, task-specific credentials, short-lived authorization, transaction limits, and separate permissions for searching, modifying a cart, placing an order, and releasing funds.

Fraud can occur on both sides of the marketplace. Buyers may use agents to exploit promotion, refund, inventory, or identity controls, while malicious sellers may feed deceptive content to influence agent selections. Merchants also face denial-of-wallet risks if agents submit impossible orders, repeatedly reserve scarce inventory, or use stale prices. Rate limits, idempotency keys, inventory revalidation, anomaly detection, and independent price checks are thus operational controls, not optional refinements.

## How the Secure Transaction Model Works

A defensible agentic transaction separates intent, authorization, execution, and evidence. Intent records what the customer wants, such as a specific product, maximum price, delivery deadline, and acceptable sellers. Authorization converts that intent into cryptographically or cryptographically equivalent machine-readable permissions. Execution carries out the approved action through narrowly scoped interfaces, while evidence records the agent's decision inputs, policy checks, payment result, merchant response, and any later reversal.

This separation prevents the language model from becoming the final authority. The model may propose an action, but deterministic services should validate the price, currency, seller, quantity, shipping destination, and total amount before payment. For high-value transactions, a deterministic system should also enforce a human-confirmation threshold. Useful starting thresholds might be any first-time merchant, any payment or account change, any order above $100, or any action involving regulated goods, although merchants must calibrate these figures to their loss exposure and customer expectations.

Tokenization and verifiable credentials can reduce the need to give an agent a primary account number. Payment authorization should ideally use a single-use or narrowly scoped token associated with the transaction, amount, merchant, and expiration. Identity assertions should prove that the customer or their delegated agent is authorized without disclosing unnecessary personal information. Verifiable privacy approaches being tested for cloud AI may eventually help, but the concept does not remove the need for merchant-side policy enforcement or an auditable payment record.

The same architecture should account for nonpayment actions. Searching a catalog normally requires less privilege than adding an item to a cart, and adding an item normally requires less privilege than ordering or changing a shipping address. A safer sequence is discovery, authenticated cart creation, policy validation, authorization, atomic order placement, and confirmation. If any step fails, retries must not duplicate charges or orders. The recurring implementation principle is to make the secure path the easiest path, rather than relying on developers to remember optional safeguards during a rushed integration.

## Reference Architecture for AI Software Teams

An AI software systems consultant would typically design agentic commerce as a distributed control system rather than as a chatbot attached to a checkout button. The front end may include a browser, mobile app, email inbox, or conversational interface, but it should call an agent orchestration layer with structured tools. That layer should expose separate operations for product discovery, policy retrieval, price comparison, cart preparation, authorization, and payment. Agents should not receive unrestricted access to a merchant database, customer account, or payment network.

Policy and identity services sit between the agent and transaction systems. They enforce delegation limits, tenant boundaries, approval thresholds, restricted categories, merchant allowlists, geographic controls, and expiration rules. A policy decision should return both the decision and a machine-readable reason so the agent can respond appropriately and the compliance team can investigate behavior. A merchant may reject automated purchase for a particular item even if the buyer's credentials are valid, just as a network can decline a transaction that meets identity requirements but violates risk policy.

The commerce backend remains the source of operational truth. ERP, order-management, inventory, tax, and payment systems should continue to hold authoritative records, while the AI agent acts as an adaptive interface. This matters because ERP and commerce systems are comparatively stable and auditable, whereas model behavior is probabilistic. Prices and stock should be revalidated at the moment of order; discounts should be calculated server-side; and a final receipt should be generated from the completed transaction rather than fabricated by the model.

Observability must connect prompts, tool calls, policy decisions, and monetary events without logging secrets or unnecessary personal data. Security teams should record the model and prompt version, selected tools, retrieved policy version, agent identity, delegation identifier, transaction amount, approval status, and final authorization reference. Sensitive fields such as full payment credentials, authentication secrets, and complete access tokens should be redacted or placed in dedicated secret stores. This creates evidence for disputes while limiting the impact of a logging breach.

## Comparison of Security Approaches

There is no single product category that solves agentic commerce security. The correct choice depends on whether an organization is validating an agent, operating a merchant endpoint, issuing payment credentials, or governing an internal AI procurement system. Comparing approaches also prevents teams from confusing a convenient demonstration with a production control.

| Feature | Consumer wallet delegation | Merchant verification layer | Payment-network controls | Enterprise orchestration controls |
| --- | --- | --- | --- | --- |
| Primary purpose | Limits what a customer's agent can buy | Authenticates and governs agent traffic | Authorizes and monitors transactions | Connects identity, policy, tools, and approvals |
| Human approval | Useful above a set amount or for new merchants | Optional by risk tier | Usually unavailable inside authorization itself | Configurable by amount, action, or risk |
| Credential exposure | Can use scoped or single-use tokens | Should not require primary account data | Tokenizes and authorizes payment | Keeps tokens in vaulted secret stores |
| Main weakness | Poor agent behavior can still create disputes | Cannot see the customer's private intent or all payment risk | Does not understand product suitability or business policy | Requires engineering and operational maturity |
| Best deployment | Consumer wallets and delegated agents | Agent-facing checkout and catalog APIs | Card, account-to-account, and tokenized payments | Regulated, high-value, or multi-system transactions |

A consumer wallet may provide the most intuitive customer control, but it cannot be the merchant's only defense. Merchant verification protects the seller from unauthorized agents and establishes machine-readable terms. Payment networks provide transaction authorization and risk services, but they generally cannot determine whether an agent misunderstood a product requirement or violated an internal procurement policy. Enterprise orchestration is needed when the agent interacts with several internal or external systems and when accountability must span more than a single checkout.
Many mature organizations will use all four rather than selecting one. For a $15 household purchase, full manual approval may add friction without reducing meaningful risk. For a $50,000 infrastructure order, a staged process involving budget validation, procurement approval, dual control, and supplier verification is justified. The control plane should therefore be proportional to transaction value, reversibility, data sensitivity, and the difficulty of detecting abuse.

## Practical Implementation Steps

Begin with a transaction inventory. Identify every action an agent can take, including searching, reading account data, changing a cart, placing an order, authorizing payment, canceling, and requesting a refund. For each action, assign an owner, data classification, financial exposure, approval requirement, and recovery procedure. Teams frequently discover that the first agent prototype can perform six or ten privileged operations, even when the visible product promises only “automated shopping.”

Next, define a typed authorization contract. It should include the customer or organization, permitted agent, merchant scope, item categories, currency, maximum amount, expiration, and approval threshold. Machine-readable constraints should override conflicting natural-language claims. Implement short-lived credentials, replay protection, idempotency keys, and server-side price verification. Use a sandbox or simulated payment mode for development, but test against real failure conditions such as timeouts, duplicate webhooks, partial stock, stale promotions, and changed shipping addresses.

Before launch, conduct adversarial testing across prompt injection, indirect instruction injection, malicious product listings, credential theft, replay, price manipulation, inventory denial, and excessive tool use. Establish measurable gates rather than relying on a subjective judgment that the agent “looks safe.” Useful measures could include a 100% rate of rejection for out-of-scope merchants, zero duplicate orders across 10,000 retry tests, 100% server-side price validation, and at least 99.9% successful policy-decision logging. These figures are design targets, not industry standards, and should be adjusted to the system.

Roll out gradually using low limits, allowlisted merchants, and a narrow product catalog. Monitor loss, approval rates, manual-review frequency, agent overrides, refund rates, duplicate attempts, and customer complaints. A pilot involving 1,000 low-value transactions can expose integration defects, but it cannot establish safety for high-value or adversarial behavior. Expand only when incident response, customer service, payment operations, legal teams, and security personnel understand how to pause the agent and reconcile uncertain transactions.

## Costs, Mistakes, and Buying Decisions

There is no universal price for agentic commerce security because cost depends on existing payment relationships, identity infrastructure, transaction volume, model usage, and the number of systems involved. A small merchant using hosted checkout and a reputable payment provider may gain basic tokenization and fraud screening with limited incremental engineering. A marketplace launching a public agent API may need API gateways, customer identity verification, policy engines, audit logs, sandbox environments, and specialist risk reviews. An enterprise deployment can become a major platform program because authorization, observability, and rollback must work across procurement, ERP, finance, and external suppliers.

The most expensive mistake is treating the language model as the control plane. Models are useful for interpreting customer goals and selecting likely actions, but they are not deterministic authorization systems. Other common errors include exposing full account credentials, allowing an agent to choose both the merchant and the final price without revalidation, failing to distinguish cart creation from payment authorization, and logging complete prompts and payment data without minimization. Security-by-disclaimer is similarly weak: saying that users remain responsible does not tell the customer what authority the agent had or how to revoke it.

Organizations should act now if agents are already capable of ordering, if a partner is piloting machine-initiated transactions, or if the business is evaluating agent-facing APIs. They can wait for a universal standard before choosing technology, but they should not wait to inventory permissions and contain risk. Regulated sectors should move sooner because audit, privacy, payment, and consumer-protection duties apply before a market label such as “agentic” becomes common. Low-risk internal pilots can use narrower boundaries, but they still need typed permissions and auditable actions.

The buying decision should ask whether a vendor controls identity, authorization, payment, and evidence or merely wraps an existing agent. References should be tested with loss data, incident exercises, and policy customization—not just successful demos. Contracts should specify data retention, breach notification, model changes, service availability, transaction liability, audit access, and responsibility when an integration causes a duplicate or unauthorized order. In agentic commerce, interoperability matters, but a shared security failure can propagate rapidly across wallets, merchants, agents, and payment networks.

## Quick answers

### Is HTTPS enough to secure an AI shopping agent?

No. HTTPS protects data in transit, but it does not determine whether an agent is authorized to spend money or follow a customer's budget and merchant restrictions. A secure deployment also needs scoped identity, typed delegation, policy enforcement, server-side price checks, payment controls, and audit evidence.

### What approval threshold should businesses use for agentic purchases?

There is no universally accepted amount. A practical starting point is to require confirmation for first-time merchants, account changes, or purchases above an agreed limit such as $100, then adjust the threshold using fraud rates, transaction reversibility, and customer expectations.

### Can an AI agent safely use a regular credit card?

The customer can use a payment card, but the agent generally should receive a token or narrowly scoped payment instrument rather than reusable primary-account credentials. Authorization should bind the credential to a merchant, amount or ceiling, transaction purpose, and short expiration window where supported.

### How do businesses stop prompt injection from hijacking an agent?

No single filter provides complete protection. Organizations should treat all retrieved content as untrusted, separate discovery from execution, restrict tool permissions, validate orders deterministically, limit network access, require approvals for high-risk actions, and test indirect injection through product pages, emails, and merchant data.

### Will agentic commerce replace traditional checkout?

It is more likely to add another interface around existing payment, identity, order, and ERP systems. Customers may initiate purchases through wallets or agents, but authoritative records and controlled backends will still be needed for inventory, tax, fulfillment, refunds, and dispute handling.

Canonical: https://zdnetinside.com/knowledge/how_should_businesses_secure_agentic_commerce_in_2026.php
Markdown: https://zdnetinside.com/knowledge/how_should_businesses_secure_agentic_commerce_in_2026.php/index.md