Large language models got surprisingly good at thinking. They work through complex problems, weigh options and explain a decision better than most internal dashboards I've seen. Then you ask them to spend money and it all slows to a crawl.
Ask an LLM to compare vendors and it shines. Ask it to actually buy something and it hits redirects, checkout pages, confirmation steps, unclear pricing and conditions hidden somewhere in the small print, because all of that was made for a person with a mouse.
The market is clearly going towards LLMs placing orders anyway (reordering supplies, booking travel, buying a software subscription from inside Search, Gemini or ChatGPT). I don't really doubt that agents will transact. I'm more interested in whether they'll do it safely, transparently and under proper governance, which is the problem the Universal Commerce Protocol tries to solve.
Think about how you buy something online. You look at a few pages, read the product text, compare two or three options and click a button, and the whole flow is designed around you sitting there making a judgment call and confirming it by hand. An LLM doesn't browse. It makes a plan and then tries to execute it.
So right now, getting an LLM to buy something means working around systems that were never meant for it. Developers scrape websites and glue brittle APIs together, or they put a human back in the loop to confirm every step. It works in a demo. It's fragile, slow and hard to scale.
I don't think payments or security are what's holding this back. The bigger issue is representation, because commerce isn't described anywhere in a form a machine can properly understand.
UCP, short for Universal Commerce Protocol, isn't trying to replace your ecommerce platform. What it changes is how commerce is exposed to software. A retailer publishes actions (rather than pages) with explicit terms and a fixed structure, so the model has nothing left to interpret. For the model a purchase becomes a defined action with known inputs, constraints and outcomes, and it no longer has to guess its way through a checkout.
Commerce becomes something models can reason about first and execute second, instead of something they have to blindly click through.
That gives the model room to think before it acts. It can check the conditions, see what it's committing to and decide whether doing this actually helps the bigger goal it was given. Doesn't sound like much, but a lot of what comes next depends on it.
Say a shopping assistant gets asked to "find a lightweight carry on suitcase under $200 that fits airline X requirements." With UCP the retailer exposes "add suitcase Y to cart" as a structured action, with explicit dimensions, price, delivery options and return terms. The model compares a set of structured offers and picks the best fit, and it never has to scrape a product page.
Or a retail agent helps a customer "replace my running shoes with the latest model in my size." It sees bookable actions like "purchase product Z in size 42" with stock status, loyalty benefits and shipping times attached. It can then optimize for price, delivery speed or member perks, and you can see exactly what it chose and why.
Then there is the promotions agent that has to "apply the best valid discount for this cart." UCP exposes discount codes and promotions as structured capabilities, so the model can figure out which discounts stack, which need specific items and what the final landed price will be, all before it commits to checkout.
The model is the same in all three cases. The thing that changed is the language commerce uses to talk to it. To business leaders I usually explain it like this. A web page describes a product for a human, a protocol describes an action for a machine, and the protocol is explicit about price, limits, approvals and outcomes.
People browse first and decide later, and LLMs decide first and then look for the best way to execute. UCP lines commerce up with the second way of working. You give the model a structured view of what's possible instead of a maze of pages and forms, and it can compare options, weigh trade offs and understand consequences without pretending to be a human user. That means a lot fewer hallucinations and mistakes, in about the most sensitive place you could have them.
You can already see platforms standardizing commerce for agents. Google's Universal Commerce Protocol defines capabilities for shopping, checkout and payments, so agents in AI Mode on Search or Gemini can safely complete purchases with instruments like Google Pay, and every authorization is backed by cryptographic proof of consent (Under the Hood: Universal Commerce Protocol). At the same time OpenAI's Agentic Commerce initiative and the Agentic Commerce Protocol (ACP) describe how ChatGPT and other agents built on OpenAI can reason over structured commerce state, call tools for product discovery, checkout and fulfillment, and keep customers updated in real time.
Back to the suitcase for a moment, because the Google implementation makes it very concrete. Today a user types "find a lightweight suitcase for an upcoming trip" into a search box or chatbot. Behind the scenes, systems scrape several retailers, guess at availability and hand the user a list of links to click through.
With UCP, retailers expose capabilities like dev.ucp.shopping.discovery and dev.ucp.shopping.checkout. An agent can discover business profiles, query structured product offers that match the constraints (dimensions, price, loyalty benefits) and then call a checkout capability with explicit line items, totals and payment options. The Google reference implementation of UCP shows how this powers AI Mode in Search and Gemini, where users go from discovery to purchase in one conversation and pay with instruments such as Google Pay, with consent you can prove cryptographically.
Discounts are the other nice example. Today customers copy and paste discount codes, try out bundles and hope the total ends up where they expected. Loyalty perks, member pricing and coupon rules are spread across fine print and UI edge cases.
With UCP, discounts become structured extensions on top of checkout. An agent opens a checkout session and applies discount codes or loyalty benefits through explicit fields, and gets back updated totals with subtotals, discounts, taxes and final amounts. The UCP samples do exactly this: the agent updates a checkout session with a code like 10OFF and receives a revised order that shows how the discount is split over line items and subtotals.
Without something like UCP, LLMs are stuck in an advisory role. They can recommend things, but they can't operate.
Make commerce machine readable and that changes. Models can go from suggesting actions to executing them, in a way that is controlled and can be audited. That takes stronger reasoning loops, better memory and clearer boundaries, which is where model architectures are heading anyway. You could say commerce forces LLMs to grow up, because this is the point where intelligence finally comes with responsibility attached.
When actions are explicit, governance stops being a spreadsheet problem and becomes a design choice.
Consumer chatbots ordering sneakers are the least interesting part of this. LLMs are starting to place real orders inside products like Gemini and ChatGPT, on top of protocols such as UCP and ACP, and the same mechanics apply to operational automation. Procurement, travel management, vendor selection, subscription optimization and yes, everyday ecommerce will more and more be handled by agents acting for teams and customers.
Once commerce is exposed as structured actions, you can hand those workflows (and the orders themselves) to systems that reason consistently, apply policy automatically and never get tired.
For business leaders that has some very practical effects. Your policies and constraints turn into executable rules instead of static PDFs nobody reads, and every action carries explicit terms and guardrails, so the model can only do what you allowed. You get fewer manual steps and handoffs, and less time waiting on approvals. The small, frequent decisions (renewals, rebookings, minor purchases) get handled the same way every time instead of ad hoc, and a model can compare the options instantly before it spends anything. Every decision and purchase is logged with its inputs, constraints and outcomes, so it traces back to a structured intent. One set of rules can cover many vendors and regions. And companies that expose their services through protocols like UCP become easier to integrate, compare and automate around, which is a new way to compete.
UCP doesn't let you skip governance. If anything it makes governance enforceable. Expose the wrong actions or set weak constraints and the model will execute them faithfully, and I'd blame the design for that, not the model.
The other misconception is that a protocol like this will "flatten" differentiation between vendors. My guess is the opposite happens and the differences get easier to see. Pricing, terms, service levels and commitments come out of the PDFs and the fine print and become comparable and testable. If your company already runs on clear policies and well defined commercial logic, that works in your favor.
None of this will excite anyone the way a new model does. UCP doesn't generate text or images and it doesn't feel intelligent at all. But it is the layer that was missing between intelligence and execution, and once it's there, LLMs can stop talking about work and start doing it.
At Blits.ai we help enterprises design, implement and govern these agentic commerce flows end to end, connecting protocols like UCP to your real systems so your agents can safely go from "recommend" to "execute." If that's on your roadmap, I'd be happy to talk.
Updated on 12 October 2026.
