For years, B2B e-commerce was about visibility: being found, looking good, convincing the human in front of the screen. That question still matters, but in 2026 it only tells half the story. More and more often there is no human in front of the screen at all, but a program that researches, compares, configures and finally orders on behalf of procurement. According to Deloitte, around 40 percent (Deloitte) of B2B buyers already use agentic AI, and 74 percent (Deloitte) plan to introduce it within two years. A Gartner forecast even assumes that by 2028 roughly 90 percent (Gartner) of B2B purchases could be initiated or handled through AI agents. Anyone who cannot be ordered from in this channel is simply skipped by the machine. This article does not show how to become visible in AI search - that is a topic of its own - but how to make a Shopware B2B shop transaction-capable for autonomous purchasing agents: with structured product data, a robust API, an agent-ready checkout, plus authentication and approval rules.
Key takeaways
- Agentic commerce shifts the core question from being found to being orderable: around 40 percent (Deloitte) of B2B buyers already use agentic AI, and 74 percent (Deloitte) plan to adopt it within two years.
- An agent does not interpret. If a purchase-relevant detail is missing as a named field, it stops - identifiers, technical attributes, price with currency and packaging unit, and availability belong in structured markup, for example the open Schema.org vocabulary.
- Without a dependable interface the channel stays theoretical: product queries, customer-specific pricing, cart operations, order placement, status feedback and clear error semantics have to be versioned and machine-usable.
- Control comes from a separate, revocable identity per agent instead of shared credentials, plus fine-grained permissions, budgets, order limits, permitted ranges and approval thresholds where a human signs off.
- The path is not a rebuild: data quality, a documented API layer, agent identities and the link to ERP and PIM can be added in stages on top of Shopware Open Source.
Why Agentic Commerce Reshapes B2B Purchasing
Agentic commerce describes a purchase in which an AI agent does not merely make suggestions but carries out steps on its own: it understands a need, searches for matching items, checks price, availability and conditions, builds a cart and - within predefined rules - triggers the order. The decisive difference from classic product search is that the machine acts instead of only informing. For merchants, the central question therefore shifts from "Am I found?" to "Can orders also be placed with me automatically?". A shop designed exclusively for the human eye - with information in images, in freely written prose or hidden behind several clicks - is hard or impossible for an agent to operate. This is exactly where it is decided whether a supplier earns revenue in the new channel or remains invisible.
The momentum is considerable. Besides the roughly 40 percent (Deloitte) of B2B buyers already using agentic AI and the 74 percent (Deloitte) who want to introduce it within the next two years, Gartner expects that by 2028 around 33 percent (Gartner) of enterprise software will contain agentic AI - up from less than one percent in 2024. In addition, by 2028 at least 15 percent (Gartner) of day-to-day work decisions are expected to be made autonomously by agents. For procurement this means: routine orders, reorders and standardized purchases move into the agent channel first, because they are clearly describable and require little negotiation. Those who can accept these orders automatically win exactly the plannable, recurring business that carries the contribution margin in B2B.
Detect the Need
The agent derives from a request, a stock level or a bill of materials what has to be procured and in what quantity - without a human starting the search.
Compare
It checks several suppliers in parallel on specification, price, availability and delivery time and filters what matches procurement's requirements.
Configure
For variants and accessories the agent assembles the right combination, provided the product logic is stored in a machine-readable way.
Build the Cart
It places line items with the correct packaging unit, quantity and customer-specific price into a cart - technically via the shop API.
Obtain Approval
If the order exceeds a limit, the agent obtains approval or submits the case to a human approver.
Order
Within the permitted limits the agent completes the order and documents it traceably for procurement and accounting.
From Searching to Ordering: the New Role of the Shop
As long as a human orders, a shop forgives many weaknesses: a buyer interprets unclear statements, searches the data sheet for the missing figure and, in case of doubt, calls. An agent does none of this. It relies on what is available in a structured and unambiguous form and aborts when a critical piece of information is missing or ambiguous. Data gaps that a human glosses over thus become hard reasons for abandonment in the agent channel. The good news: the same diligence that makes a shop agent-ready also improves the experience for human buyers, because clear data, stable processes and unambiguous prices benefit everyone. Investing in machine-readable quality today is not spending on an exotic fringe channel but on the core substance of your own shop.
The pressure to act here also stems from the expectations on the customer side. Even today, according to Forrester, around 44 percent (Forrester) of B2B buyers switch supplier when the digital experience is unconvincing, and about 73 percent (Forrester) of professional buyers now belong to the millennial and Gen Z generations, who take digital self-service for granted. When these buyers begin to delegate routine tasks to agents, they expect their preferred suppliers to play along. A supplier that cannot be ordered from automatically then drops out of the selection not through a single person but systematically - the agent simply finds a path that works. How visibility and transaction capability complement each other is deepened in our article on how products become visible in AI search for business customers.
Visibility and Orderability Are Two Different Tasks
Machine-Readable Product Data as the Foundation
The foundation of every agent-ready shop is clean, structured product data. An agent must be able to recognize, without human interpretation, which item is meant, what specification it has, what it costs, whether it is available and in which unit it is sold. Free-text descriptions and images are not enough for this; the core information has to be present as unambiguous, named fields. The open vocabulary of Schema.org has proven effective for this, supplemented by common industry identifiers such as GTIN or manufacturer part number. How strongly data quality decides success is shown in detail in our article on product data and PIM as a data source - in the agent channel a matter of comfort becomes a hard prerequisite.
- Unique identifiers per item: SKU, GTIN and manufacturer part number, machine-readable
- Technical characteristics as named attributes, not only as prose in the description field
- Price as a structured field including currency, tier and packaging unit
- Availability and delivery time as current, queryable values rather than an image or a traffic light
- Variants, accessories and successor items logically linked and unambiguously referenced
- Sustainability and compliance data such as CO2 figures as separate, readable fields
A concrete example makes the difference tangible. Instead of offering a description like "grey cable trunk, ex stock, cheap", an agent-ready shop stores the same information as structured data that an agent can reliably read out. The following simplified example shows how a product with price, availability and B2B characteristics can be marked up in the Schema.org format. The values are illustrative; what matters is the principle of providing every purchase-relevant detail as a named field.
{
"@context": "https://schema.org",
"@type": "Product",
"sku": "A-2041-60",
"name": "Kabelkanal 60x40 mm, grau",
"gtin13": "4012345678901",
"brand": { "@type": "Brand", "name": "Muster Technik" },
"offers": {
"@type": "Offer",
"priceCurrency": "EUR",
"price": "3.90",
"priceValidUntil": "2026-12-31",
"availability": "https://schema.org/InStock",
"inventoryLevel": { "@type": "QuantitativeValue", "value": 1840 },
"eligibleCustomerType": "B2B",
"eligibleQuantity": { "@type": "QuantitativeValue", "minValue": 12, "unitText": "Stück" }
}
}Sustainability data is also gaining weight in the agent channel, because many purchasing policies now contain ecological criteria and an agent can only take these into account if they are available in structured form. How the product carbon footprint can be shown as a CO2 figure in the B2B shop and maintained is covered in our article on it. For agent readiness the same principle applies as for price and availability: what procurement uses as a criterion must exist as a readable field, otherwise the item fails the automatic selection.
One API and a Checkout for Agents
Structured data alone is not enough - the agent must also be able to act. For this the shop needs a stable, documented programming interface through which items can be queried, carts created, customer-specific prices determined and orders triggered. Shopware open source provides a solid foundation with its Store API and Admin API on which agent-ready flows can be built. What is decisive is that the interface works reliably, versioned and traceably: same request, same response, clearly documented fields and errors. An agent can do little with an erratic or poorly described interface; it needs predictability. What a viable interface architecture for B2B shops looks like is shown in our article on it.
- Product query: deliver items, attributes, tier prices and availability in a structured way
- Per-customer pricing: apply customer-specific conditions and framework contracts correctly
- Cart operations: create and change line items and calculate with packaging units
- Order placement: create the order and take payment method and delivery address from the account
- Status feedback: keep order confirmation, delivery status and documents machine-retrievable
- Clear error semantics: unambiguous codes so the agent can handle edge cases cleanly
Around agentic commerce, open protocols are currently emerging that aim to standardize the exchange between agent and shop - for example approaches with which agents address tools and catalogs in a standardized way, as well as new protocols for the approval of payments by agents. These standards are still young and in flux, so it is worth building your own interface so that it can dock onto emerging protocols without having to rebuild the whole shop. A cleanly separated API layer makes exactly that possible: the core stays stable while the connection to new agent channels is added as an adapter. This keeps the shop connectable without committing prematurely to a single, still unfinished standard.
Authentication and Approval Rules for Autonomous Buyers
As soon as a machine orders in the name of a customer, control becomes the core question. The shop must reliably recognize which agent acts for which customer with which rights, and may allow it only exactly what the customer has approved. This means: a dedicated, revocable identity per agent instead of shared credentials, fine-grained permissions and a complete log of all machine transactions. Limits are just as important: budgets, order limits, permitted assortments and approval thresholds above which a human must consent. This logic is not a reinvention but a consistent extension of what good B2B shops already provide for approval workflows, authorizations and budgets - only that the trigger can now also be an agent.
Dedicated Agent Identity
Each purchasing agent receives its own, revocable access authorization - no shared passwords, so that every action can be attributed to an agent.
Fine-Grained Rights
The agent may use only certain assortments, quantities and payment methods; everything else stays blocked, even if the underlying customer would have more rights.
Budgets and Limits
Order value, period budget and single-line limits bound the scope of action. When a limit is reached, the process stops or goes into approval.
Traceable Log
Every machine action is logged - who, when, what, at what amount. This creates auditability for procurement, internal audit and accounting.
Security is not an afterthought here but a condition. A machine channel enlarges the attack surface if implemented sloppily: compromised credentials, manipulated requests or an agent acting outside its limits can cause real damage. That is why strong authentication, strict permissioning, rate limiting and anomaly detection belong in the architecture from the start. How a B2B shop is secured technically and organizationally is placed in context by our article on IT security and NIS2 in the B2B shop. For new or unknown agents, an automatic check of creditworthiness and order limits is additionally advisable, as described in our article on payment default and credit checks in the B2B shop. The principle is: give an agent as much scope for action as the customer explicitly permits - and not one millimeter more.
Agentic Commerce Versus the Classic Checkout
A look at the differences makes clear why the agent channel calls for its own consideration and does not simply pass as another frontend variant. Where the human checkout relies on screen, interpretation and spontaneous decision, the agentic flow demands structured data, clear rules and machine traceability.
| Attribute | Classic Checkout | Agentic Commerce |
|---|---|---|
| Actor | Human at the screen | Software on behalf of procurement |
| Product data | Image and prose suffice | Structured, named fields required |
| Access | Login in the browser | Dedicated, revocable agent identity |
| Decision | Interpretation and gut feeling | Rules, limits and approvals |
| Error tolerance | Human asks back or calls | Abort when ambiguity remains |
| Proof | Order history in the account | Complete machine log |
It is important not to play the two channels off against each other. The human checkout remains central for advice-intensive, complex or new needs, while the agent channel efficiently handles the plannable, recurring orders. A well-thought-out B2B shop serves both from the same data base and the same rules, so that prices, availabilities and approvals are identical in every channel. It is precisely this common foundation that prevents contradictions between what a human sees and what an agent can read out. Portals and self-service, as laid out in our B2B portals, form a natural basis for this.
Making Shopware Agent-Ready: the Pragmatic Path
The path to an agent-ready shop does not lead through a radical rebuild but through targeted expansion stages on a solid base. Shopware open source provides the building blocks - Store API, Admin API, customer groups, roles and rights - to allow machine orders in a controlled way. The pragmatic approach starts with data quality, adds a cleanly documented API layer, introduces authentication and approval rules for agents and interlocks the whole with ERP and PIM, so that prices, stocks and orders are correct in real time. This creates a channel that is robust without endangering the existing shop. The tight connection to the ERP system is not an extra but the core of any solid ERP integration for the B2B shop.
An agent-ready shop is not a new shop but a well-run shop whose data and rules are so unambiguous that even a machine can follow them.
The comparison to existing procurement connections helps to gauge the effort realistically. Those who already serve large customers via catalog connections such as punchout and OCI know the pattern that a foreign system accesses their own catalog in a structured way and returns line items. Agentic commerce continues this idea but replaces the fixed foreign system with a flexible, AI-driven agent. The technical requirements for clean data, clear interfaces and regulated approvals are very similar - which explains why suppliers with well-maintained procurement connections often have a shorter path into the agent channel.
Step by Step to an Agent-Ready Shop
An agent-ready shop does not emerge overnight but in manageable stages that can be used individually. Those who begin with data quality immediately improve the experience for human buyers as well and at the same time create the prerequisite for everything else. On top of this build the API layer, the access and approval logic and finally the connection to emerging agent protocols. Since already 74 percent (Deloitte) of buyers plan to adopt it within two years and by 2028 around 90 percent (Gartner) of B2B purchases could run through agents, a gradual but swift entry makes more sense than waiting until the channel is mature - because the plannable orders move first, and experience shows they do not return on their own.
- Structure product data: make identifiers, attributes, prices and availability machine-readable
- Document the API layer: stable, versioned endpoints for query, cart and order
- Introduce agent identities: dedicated, revocable access instead of shared credentials
- Define approval rules: set budgets, limits, permitted assortments and approval thresholds
- Interlock ERP and PIM: keep prices, stocks and orders synchronized in real time across channels
- Stay connectable: build the interface so that new agent protocols can dock on as adapters
At the start there is rarely the technology but the question of which orders are suitable for the agent channel at all. Standard items, reorders and clearly specified line items are ideal candidates; advice-intensive projects stay with the human for now. Those who take this prioritization seriously can start with a few, high-quality flows and expand the channel based on real machine usage. Which stages make sense for your shop and how the effort can be realistically estimated is shown by comparable project approaches; the concrete implementation is something we are happy to discuss in direct contact.