What B2B software sellers should prepare for AI buying agents: structured pricing, written quote rules, a trial without a chaser, and what stays human. Agentic commerce is buying in which a software agent acts for the buyer: it researches, compares, asks for a quote and, where it holds signed authority, pays.
Agentic commerce is buying in which a software agent acts for the buyer: it researches, compares, asks for a quote and, where it holds signed authority, pays. For a B2B software seller, most of that is not ready. What has arrived is narrower: agents that read your pricing page, fill in your forms and request quotes for a person.
The payment standards are at an early version, and ChatGPT's Instant Checkout has already been scaled back. So the work worth doing now is the unglamorous part. State your packaging in a form a machine can read, write your quote rules down, make the trial and quote path work without anyone chasing it, and keep a record of what was agreed. That helps human buyers straight away, and agent buyers whenever they arrive. Negotiation, security review and legal stay with people.
What changes when an agent is the buyer
A person reading a pricing page fills gaps with judgement. They read "Contact sales" on the top tier as a hint that the price moves, they guess what "unlimited" leaves out, and they email someone when a limit is unclear. An agent fills the same gaps with guesses, or stops, and then reports back to the person it works for.
Three things change for the seller.
- Your pages are read literally. A seat minimum that appears only in the terms, or an add-on priced only in a sales deck, is missing from the agent's summary. If another vendor states the same facts plainly, the comparison your buyer sees is made on their terms.
- Your quote form becomes an interface for software. A form that cannot finish without a phone call, or a quote that exists only after a rep has qualified the lead, is a dead end for an agent. It is also a slow path for the human it replaces.
- Who is asking becomes a real question. A request from an agent is only as good as the authority behind it. You need to know which person and organisation it speaks for, and what it may commit to.
None of this needs a new protocol. It needs the commercial logic that lives in your sales team's heads written down where software, and new colleagues, can read it.
What exists now, and what is still a forecast
The protocols are real, open and young. Read each at its source rather than through a vendor's summary of it.
| Standard | Who stands behind it | What it does | Status we could verify |
|---|---|---|---|
| Agent Payments Protocol (AP2) | Google; now with the FIDO Alliance | Signed "mandates" record what a user authorised an agent to buy and pay | Version 0.2; donated to FIDO on 28 April 2026 |
| Verifiable Intent | Co-developed by Mastercard and Google; contributed to FIDO | Links identity, intent and action so an agent can prove its scope | Open specification under Apache 2.0 |
| Agentic Commerce Protocol (ACP) | OpenAI and Stripe | Checkout, delegated payment, cart, product feed and orders between agents and businesses | Beta; latest stable release dated 17 April 2026 |
| Universal Commerce Protocol (UCP) | Google, co-developed with Shopify, Walmart and other retail and platform companies | Catalogue search, cart building, identity linking, checkout and order management | Checkout in Google's AI Mode and Gemini; merchants join a waitlist |
| Model Context Protocol (MCP) | Open protocol | Lets a business expose tools, such as a quote request, to AI applications | Open specification; the host must get the user's consent before calling a tool |
Google announced AP2 in September 2025 with more than 60 organisations. Its central idea is the mandate: a cryptographically signed record of what the user instructed. On 28 April 2026 Google donated AP2 to the FIDO Alliance and released version 0.2, which adds "Human Not Present" payments, where an agent pays on instructions the user approved in advance. The same day, the FIDO Alliance set up an Agentic Authentication Technical Working Group, chaired by people from CVS Health, Google and OpenAI, and gave agent-initiated commerce to its Payments Technical Working Group, chaired by people from Mastercard and Visa. Their specifications will draw on AP2 and Mastercard's Verifiable Intent.
ACP started life behind Instant Checkout in ChatGPT. In March 2026, OpenAI said that first version did not offer the flexibility it wanted, and moved to letting merchants use their own checkout while ChatGPT concentrates on product discovery. That is the clearest public signal that agent checkout is still being worked out, even for consumer goods.
UCP, launched in January 2026, is aimed at retail first; Google's merchant page names lodging and food as the next industries. All of these are built around carts, checkouts and payments. A negotiated B2B order with approvals on both sides is not where any of them starts.
What is already happening is agents using ordinary web pages. Google's auto browse in Chrome, in preview since January 2026 for Google AI Pro and Ultra subscribers in the US, handles multi-step tasks, and Google says testers have used it to get quotes from plumbers and electricians. It stops to ask for confirmation before sensitive steps such as completing a purchase. Agents are also starting to identify themselves: Cloudflare's Web Bot Auth verifies bots and agents through HTTP message signatures (RFC 9421).
Then there are forecasts. Gartner predicts that by 2028, 90% of B2B buying will be AI agent intermediated. That is a prediction, not a measurement, and we would not set a roadmap by it. Plan around what is already true: agents read your pages, fill in your forms and ask for quotes.
Why B2B buying does not fit a consumer checkout
B2B has bought through machines for a long time. cXML defines purchase orders, order confirmations, ship notices, invoices and the PunchOut link between a buyer's procurement system and a supplier's catalogue. What is new is not machine buying. It is a reasoning agent on the buyer's side that reads pages written for people and tries to act on them.
That agent meets four things a consumer checkout never has to handle:
- Price that depends on the customer. Volume, term, region, the buyer's existing contract and the stage of the deal all move the number. A cart assumes one price per item.
- Approvals on both sides. The buyer's budget holder must sign off, and on your side someone holds discount authority. Neither is a payment step.
- A contract, not a receipt. An order form, terms, a data processing agreement and sometimes a master agreement sit behind the purchase.
- A security review. Software buyers check how you handle their data before they sign.
Contracts formed by software are not a new legal question either. The UN convention on electronic communications in international contracts, adopted in 2005, allows for the enforceability of contracts entered into by automated message systems (Article 12) and sets remedies for input errors that people make in them (Article 14). The design lesson we take from that: give the person behind the agent a clear point to check and correct an order before it binds.
Prepare now, wait on, keep human
This is how we would sort the work for a B2B software company that does not want to bet its roadmap on a forecast.
| Item | Decision | Why |
|---|---|---|
| Packaging and pricing stated in structured form: plans, units, limits, add-ons, eligibility, what is quote-only | Prepare now | Human buyers compare more easily; an agent cannot infer what you leave out |
| Quote rules and approval limits written down | Prepare now | An agent's request needs an answer your rules can give without a meeting |
| A trial and quote path that needs no chaser | Prepare now | Dead ends lose people and agents alike |
| A way to confirm who the agent acts for | Prepare now | A quote nobody can sign wastes everyone's time |
| A record of what was offered, changed and accepted | Prepare now | Disputes, renewals and, later, signed mandates all depend on it |
| Agent payment credentials (AP2, Verifiable Intent) | Wait on | Still being standardised in FIDO working groups; AP2 is at version 0.2 |
| Agent checkout for contract sales (ACP, UCP) | Wait on | Built around carts; ACP is in beta, and the best-known consumer launch has already been reworked |
| Agent-to-agent negotiation of price and terms | Wait on | Discount authority is a business decision; let your written rules run with people before you hand it over |
| Negotiation outside the rules | Keep human | This is where judgement and relationships earn their keep |
| Security review | Keep human | The buyer's security team decides; your answers need an owner |
| Legal terms and signature | Keep human | Someone with authority signs on each side |
Make pricing and packaging readable by a machine
Machine-readable pricing does not mean publishing every price. It means stating precisely what you do publish, and saying clearly what you do not. For each plan, an agent (and a careful human) needs:
- the plan name and who it is for;
- the unit you charge by: seat, account, usage or a mix;
- the billing period and the minimum term;
- minimum and maximum quantities;
- what is included, and the limits that apply;
- add-ons, and which plans they work with;
- for anything priced by quote, what the quote depends on.
Say it in the visible page first. Then, if you use structured data, say exactly the same thing there. schema.org already has the vocabulary: an Offer carries eligibleCustomerType, eligibleQuantity and priceSpecification, and a UnitPriceSpecification carries referenceQuantity (the price per what), billingDuration, billingStart and priceComponentType. A minimal per-seat plan looks like this, with your own values in place of the placeholders:
{
"@context": "https://schema.org",
"@type": "Offer",
"itemOffered": { "@type": "Service", "name": "Example product, Team plan" },
"eligibleCustomerType": "http://purl.org/goodrelations/v1#Business",
"eligibleQuantity": { "@type": "QuantitativeValue", "minValue": 5, "unitText": "seats" },
"priceSpecification": {
"@type": "UnitPriceSpecification",
"price": "<price per seat>",
"priceCurrency": "<ISO 4217 code>",
"referenceQuantity": { "@type": "QuantitativeValue", "value": 1, "unitText": "seat" }
}
}
Whether a given agent reads markup varies, so treat it as a second statement of the page, never a replacement. Its real value is that it forces precision. You cannot write minValue for a seat minimum you have never decided. A contradiction between the page, the markup and your help centre is worse than a gap: the agent will report one of them, and you will not know which.
Write the quote rules down before an agent asks
Most B2B quote rules exist, but in people's heads and in old email threads. An agent's request exposes them quickly. Write down:
- which requests can be quoted without a person, such as standard plans at list price or published volume tiers;
- the discount bands, and who can approve each one;
- how long a quote stays valid, and what happens when it lapses;
- which requests always go to a person: custom terms, unusual data residency, a request above a set value;
- what information a quote needs before it can be produced.
Then make the rules explain themselves on the quote, as we argue for CPQ interfaces: when a line needs approval, say so and say why. A human rep and a buyer's agent both handle a stated rule better than a silent delay.
When we designed the MVP of a CPQ product for heavy industry with Auxentios, eight interviews across six roles, from sales representatives to pricing and solution experts, showed that a quote is built by several specialists. We mapped who contributes what to a quotation, where information changes and where work is handed over. That map is also the start of an agent-ready quote path: at each hand-off, a request either follows a written rule or waits for a named person.
A quote and trial path that runs without a chaser
The test is simple: can someone who never speaks to your sales team get from interest to a usable quote or a working trial? If not, an agent cannot either.
- Trial. Let it start without a mandatory call. State its limits, its length if it has one, and what happens at the end.
- Quote request. Ask only for what your quote rules need. Label every field, accept typed input instead of click-only widgets, and return errors in words. Our test of what breaks when AI agents use SaaS screens covers the form patterns that stop agents.
- Response. Return either a quote or a stated next step with a named owner and a reference number. "Someone will be in touch" is a dead end.
- The quote itself. Line items, units, term, validity and conditions as structured data or text, not only as a picture in a PDF.
- A direct door, later. Once the rules are written, a quote request can also be offered as an API or an MCP tool. Among its key principles, the MCP specification asks host applications to get the user's explicit consent before calling any tool; the protocol itself cannot enforce that, so the host's design is what keeps the person behind the agent in the loop.
Know who the agent speaks for
On the buyer's side, the new standards are mostly about exactly this. AP2's open mandates capture the user's constraints before a specific cart is finalised, such as a budget and allowed payment instruments, and a closed mandate authorises one finalised checkout. Verifiable Intent describes a chain from identity to intent to action. FIDO's new work names "verifiable user instructions" and "trusted delegation for commerce" as focus areas. None of it is yet a settled B2B standard.
Until it is, the seller's version is plain:
- ask for the principal: a named person, a work email and the organisation they buy for;
- state on the quote what it commits each side to, and what it does not;
- require a confirmation from a person with authority before an order binds, as Chrome's auto browse already does before a purchase;
- record the agent's identity where it offers one, such as a signed request.
Keep a record of what the agent agreed to
AP2's design goal is a non-repudiable audit trail from intent to cart to payment. You can build the seller's half of that now, with no new protocol:
- each quote as a version, with the plan data, prices and terms exactly as they stood when it was issued;
- who requested it, and through what (a person, an agent, an API key);
- every change, and who made it;
- the confirmation: who accepted, when, and against which version of the terms.
Make the record readable by your finance and sales people, not just your logs. When a renewal comes round or a dispute starts, the first question will be what the buyer's agent saw and what a person approved.
What stays human
In our view, buyers' agents will not replace the B2B sales conversation soon, and the moments that matter most should stay with people.
- Negotiation. Agents can gather options inside your written rules. Anything outside them is a conversation.
- Security review. Publish what reviewers ask for in a stable place, such as answers to the Cloud Security Alliance's CAIQ, a set of yes or no questions a cloud customer may ask a provider. An agent can collect it. The judgement stays with the buyer's security team, and every answer needs an owner on your side.
- Legal terms and signature. Order forms, data processing terms and master agreements are agreed and signed by people with authority.
A quote-path checklist for agent buyers
Run this against your own pricing page, trial and quote request:
- Every plan states its unit, billing period, minimum term and quantity limits on the page.
- Add-ons say which plans they work with.
- Anything priced by quote says what the quote depends on.
- Structured data, where used, says exactly what the page says.
- Quote rules, discount bands and approval limits are written down, with an owner.
- A trial starts without a call, and its limits and end are stated.
- The quote form has labelled fields, typed input and errors in words.
- Every request returns a quote or a named next step with a reference.
- Quotes carry line items, units, term, validity and conditions as text or data.
- You ask who the agent acts for, and a person with authority confirms before anything binds.
- Every quote is versioned, with its requester, changes and acceptance recorded.
- Security documents sit in one stable place, with an owner for each answer.
None of these waits on a protocol, and each one helps the human buyer first. It is the same work we do on commerce and transactional products: answering the buyer's questions before payment, so nobody has to email to find out.
About the authors
Chirag Patel
Product Designer
More from ChiragChirag Patel is a Product Designer at Tcules who writes about AI product UX and the decisions behind it. Chirag's articles ask practical questions: should search and the AI assistant share one input, how should users choose a model, what changes when the interface itself is generated, and how should AI usage be billed and shown. Other pieces cover AI chatbot design for B2B products, admin consoles for governing AI agents, search in data-heavy SaaS, and whether designers should write prompts with ML engineers. Chirag has also co-written on keeping a front-end build true to its design.
Yash Gidwani
Product Designer
More from YashYash Gidwani is a Product Designer at Tcules who writes about getting people into a SaaS product and keeping them there. Yash's guides cover SaaS onboarding strategies, onboarding and engagement software, and redesigning a live product without upsetting the people who use it. Other articles go into specific workflows: lending and loan origination apps, insurance quoting and claims, staffing and recruitment software, and a search-first create flow that stops duplicate records. Yash has also co-written the SaaS UX audit checklist and a 20-question checklist for legacy modernisation readiness.