In short and in plain language
This text is about shops where companies buy from other companies. More and more, a program buys there instead of a person. It is called an AI agent. It searches, compares and orders.
The program does not guess. It needs clear data for each item, such as price and stock. If something is missing, it stops.
The shop needs a good interface. Through it, the agent asks for prices and places orders.
Each agent gets its own access with rights and limits. Above a limit, a person has to agree.
You do not have to rebuild your shop for this. You can go step by step. We can help you with this.
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. Increasingly 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. In a Deloitte survey of more than 1,000 suppliers and buyers in the United States, nearly 40 percent (Deloitte) of B2B buyers said they already use agentic AI in purchasing, for example to evaluate products, configure orders and benchmark prices. Gartner forecasts that by 2028, 90 percent (Gartner) of B2B buying will be intermediated by AI agents. Anyone who cannot be ordered from in this channel is passed over 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, authentication and approval rules. On top of that it covers the state of agent protocols in November 2026, a fully worked approval example and the questions that should be settled in the contract before the channel goes live.
Key takeaways
- Nearly 40 percent (Deloitte) of surveyed B2B buyers in the United States use agentic AI in purchasing; Gartner forecasts that by 2028, 90 percent (Gartner) of B2B buying will be intermediated by agents.
- 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 Schema.org.
- Agents order through the Store API within the customer account, not through the Admin API: idempotency prevents duplicate orders, batch queries respect rate limits, and clear error codes control the handover to humans.
- The shop checks the rules, not the agent: a separate identity per agent, a cost center, permitted product groups, per-order and monthly budgets, and four-eyes approval above a defined order value.
- Between businesses, input correction and order acknowledgment can be agreed differently (Section 312i(2) BGB) - a framework contract for the agent channel settles attribution, cancellation and liability.
- Agent protocols are young in November 2026 and the Shopware extension for them is in beta: a separate API layer with adapters keeps the shop connectable without rebuilding it.
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 but unevenly spread. On the supplier side, according to the same Deloitte survey, only 24 percent (Deloitte) of suppliers use agents in the sales process, while 67 percent (Deloitte) plan to. Gartner expects that by 2028 33 percent (Gartner) of enterprise software applications will include agentic AI - up from less than one percent in 2024 - and that at least 15 percent (Gartner) of day-to-day work decisions will be made autonomously by agents. In Germany, slightly more than a quarter of enterprises with ten or more employees used artificial intelligence at all in 2025, namely 26 percent (Destatis); among enterprises with more than 250 employees the share was 57 percent (Destatis). 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 also stems from the buying experience. In the Deloitte survey, suppliers estimate that on average 13 percent (Deloitte) of their sales bids are lost due to a negative buyer experience, and buyers spend nearly 30 percent (Deloitte) more with suppliers that deliver a great one. Once buyers delegate routine tasks to agents, the buying experience turns into a technical question: does the agent get all the way to the order with you or not? A supplier that cannot be ordered from automatically then drops out of the selection not through a single person but systematically - the agent looks for 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. For the agent to see the same prices, stock levels and delivery times as your inside sales team, shop, ERP and PIM have to be synchronized in near real time - our page on integrations between shop, ERP and PIM describes how that works.
- 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
Which Shopware Endpoints a Purchasing Agent Uses
For orders on behalf of a customer, the Store API is the right path, not the Admin API. The vendor documentation sums up the rule of thumb briefly: the Admin API creates and manages data, the Store API acts like a shopper (Shopware documentation). It works with two headers: sw-access-key authenticates the sales channel, sw-context-token identifies the shopper context including the cart. The order is created with POST /store-api/checkout/order; in a standard setup this call requires a logged-in customer, and with an anonymous context Shopware responds that no customer is logged in (Shopware documentation). For B2B that is good news: customer group, stored prices, payment terms and delivery addresses belong to the customer account and therefore apply to the agent as well. The Admin API, by contrast, belongs in the hands of your own integrations - ERP, PIM, approval service - because, depending on its permissions, it reaches customers, prices and settings across all accounts. Inside sales teams know a related pattern when they order on behalf of the customer: there, too, it must remain visible later who actually triggered an order.
| Agent step | Store API call | What the shop should check |
|---|---|---|
| Open a context | GET /store-api/context | valid sales channel key, agent assigned to a customer account |
| Log in | POST /store-api/account/login | separate access per agent, no shared password, lockout after failed attempts |
| Search items | POST /store-api/search | permitted product groups only, price per customer group |
| Add a line item | POST /store-api/checkout/cart/line-item | packaging unit, minimum quantity, the agent's assortment limit |
| Check the cart | GET /store-api/checkout/cart | customer price, delivery time, remaining budget |
| Place the order | POST /store-api/checkout/order | approval level, order value limit, protection against double submission |
Duplicate Orders and Load Peaks: Idempotency and Rate Limits
An agent repeats a request when the response does not arrive - harmless for a price query, expensive for an order. Shopware closed exactly this case with version 6.7.15.0 of October 1, 2026: two overlapping submissions of the same cart, for example through a retried request, could previously produce two orders. Since then the order call re-checks inside the cart lock whether the cart still exists and otherwise answers with status 404 and the code CHECKOUT__CART_TOKEN_NOT_FOUND (Shopware release notes). For your own order and approval endpoints, an idempotency key is worth adding: the agent sends a unique identifier per order intent, and on a repetition the shop returns the result it already produced instead of ordering again. For the Idempotency-Key header, a draft is under way at the IETF; in October 2026 it reached revision 08 and is not yet an approved standard. It provides that a server responds with status 422 when the same key is reused with a different payload (IETF) - which exposes an agent sending a changed order under an old identifier.
The second brake is rate limiting. Status code 429 means that a client has sent too many requests in a given amount of time; the response may use Retry-After to state how long it should wait (RFC 6585). According to the vendor documentation, Shopware limits Store API access via the Model Context Protocol to 120 requests per minute and 600 per ten minutes, counted per sales channel and context (Shopware documentation). A worked calculation shows what that means: if an agent queries the 400 line items of a bill of materials one by one, at 120 requests per minute it needs at least a good three minutes (400 divided by 120 is 3.3); if it queries the same 400 line items in batches of 100, it takes four requests. Good agent interfaces therefore offer batch queries for prices and stock and report limits in machine-readable form instead of silently dropping the connection.
Agent Protocols: the State in November 2026
Several open protocols have emerged around agentic commerce, each governing a different part of the flow. None of them replaces the shop: they define how an agent finds tools, talks to other agents, initiates a checkout or authorizes a payment in a verifiable way. The overview shows the state as the project pages report it in mid-November 2026.
| Protocol | Purpose | State in November 2026 | Meaning for the B2B shop |
|---|---|---|---|
| Model Context Protocol | agent accesses tools, data and interfaces | revision 2026-07-28 (modelcontextprotocol.io); Shopware has shipped an experimental Store API server since 6.7.11.0 (Shopware documentation) | quick entry, but every custom tool has to check its own permissions |
| Agent2Agent | agents from different vendors coordinate and delegate subtasks | specification 1.0, project under the Linux Foundation (a2a-protocol.org) | matters once buying and selling agents negotiate directly with each other |
| Universal Commerce Protocol | catalog, cart, checkout, order and account linking | revision 2026-08-25 (ucp.dev); Shopware extension in beta (Shopware documentation) | explicitly provides for merchants without guest checkout; prices and payment terms stay with the shop |
| Agent Payments Protocol | verifiable purchase and payment authorizations from the user, called mandates | version 0.2, standardization in working groups of the FIDO Alliance (ap2-protocol.org) | basis for handing budget limits to an agent in a tamper-evident way |
| Agentic Commerce Protocol | checkout between buyer agent and merchant | maintained by OpenAI and Stripe, beta, latest dated revision 2026-04-17 (GitHub project) | monitor, and connect as an additional adapter if needed |
For B2B purchasing, two details matter more than the names. First, the Universal Commerce Protocol specification contains an example profile for a wholesaler that allows no guest checkout: every checkout step requires an authenticated user, and whether someone counts as a business customer, which prices they see and which payment terms apply is resolved by the merchant at runtime (ucp.dev). Second, a checkout there has to be finalized by the user through a trusted interface unless the mandates extension of the Agent Payments Protocol is supported (ucp.dev). In plain terms: the protocols carry intent and cart, but customer prices, payment terms and approvals stay in the shop and the ERP. That is exactly where it is decided whether the agent channel is fit for B2B.
The official Shopware extension shows how mature things are: in November 2026 it carries beta status, and in a reply to a review in the store the vendor points out that some of the protocols used do not yet have a stable version and recommends testing on a test instance (Shopware Store). This leads to the architecture rule: build your own interface so that a protocol can be docked on as an adapter without rebuilding the whole shop. The core with product data, customer prices and approval rules stays stable, and the connection to individual agent channels remains replaceable.
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.
Worked Example: a Reorder Agent with Budget, Cost Center and Four-Eyes Rule
A fully worked example with freely chosen values shows how the rules take effect day to day. An industrial customer sets up an agent for its maintenance department that reorders cable trunking and fastening material. The shop stores the following for this agent: cost center 410 (maintenance, north plant), only the product groups cable management and fastening technology are permitted, and the monthly budget is 25,000 euros net. Up to 5,000 euros per order the agent orders without asking; above that the team lead approves, and from 15,000 euros the head of purchasing approves as well. Pending approvals reserve the budget so that the agent does not keep ordering while it waits. The cable trunk costs 3.90 euros per piece and is sold in units of 12 pieces.
| Event in November | Net order value | Budget afterwards | Rule that applies | Outcome |
|---|---|---|---|---|
| Nov 3: 600 pieces of cable trunk | 2,340.00 euros | 22,660.00 euros left | below 5,000 euros per order | ordered without asking |
| Nov 10: 1,440 pieces of cable trunk | 5,616.00 euros | 17,044.00 euros left | above 5,000 euros | waits for the team lead, budget reserved |
| Nov 17: fastening material for a retrofit | 16,200.00 euros | 844.00 euros left | above 15,000 euros | four-eyes approval by team lead and head of purchasing |
| Nov 24: 300 pieces of cable trunk | 1,170.00 euros | 844.00 euros left | monthly budget insufficient | rejected with remaining budget, a person decides |
| Nov 25: cordless screwdriver | 189.00 euros | 844.00 euros left | product group not permitted | rejected regardless of the amount |
Two points decide whether this works in practice. First, the shop checks the rules, not the agent: an agent can be misconfigured or manipulated, and the limit in the shop still holds. Second, when an order is rejected the agent receives a machine-readable reason with an error code and the remaining budget, so it hands the case over to a person cleanly instead of trying again with smaller partial quantities. An additional rule helps against this splitting by adding up several orders from the same agent within a short time for the approval threshold: three orders of 1,800 euros each in one morning add up to 5,400 euros and therefore go into approval, even though each one on its own is below the limit.
Every machine order needs a record that still holds months later: the agent's identifier, the linked customer account and the responsible person at the customer, cost center, the idempotency key of the request, the price and rule version at the time of the order, and the name and time of every approval. The order itself is usually a received business letter for the merchant; commercial law requires it to be kept for six years, and accounting vouchers for eight years (Section 257(4) HGB). How to organize retention periods, storage and access in the customer account is shown in our article on where order documents live and how long they stay.
Liability for Wrong Orders: What the Framework Contract Should Settle
If an agent orders the wrong quantity or the wrong item, the question arises to whom the order is attributable and who bears the damage. German law starts with the general obligations in electronic commerce: the merchant must provide technical means by which input errors can be recognized and corrected before the order is placed, and must acknowledge receipt of the order electronically without undue delay (Section 312i(1) BGB). Between contracting parties who are not consumers, however, these obligations can be agreed differently (Section 312i(2) BGB). That is the lever for the agent channel: instead of relying on an order summary that an agent does not read the way a person does, a framework contract with the customer sets the rules of the game. It typically covers these points:
- Attribution: orders placed by a registered agent within the stored limits count as orders of the customer
- Confirmation channel: machine order confirmation also sent to a fixed address of the customer, not only to the agent
- Correction window: up to which processing stage an order can be canceled or changed, for example until picking starts
- Price and quantity errors: how both sides handle obviously wrong prices, units or quantities
- Credentials: obligation to block compromised agent access immediately, and how damage is shared until the block is reported
- Evidence: which log data both sides retain and how disputes are resolved based on the log
This list does not replace legal advice; it contains the questions that should be settled with your legal department or law firm before launch. If you already map framework contracts and call-off orders in the shop, add a section for machine call-offs to the existing agreement instead of drafting a new contract. The technical side follows from it: what the contract calls a correction window, the shop has to map as a status, and what is agreed as a limit has to exist as a rule in the shop.
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 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. Where the channels differ is shown in the next section.
Agent, Punchout or EDI: Which Channel for Which Order
Agentic commerce is easily confused with two older paths and one newer one: punchout and EDI have connected external purchasing systems for years, and AI research decides whether an agent finds your assortment at all. The channels answer different questions and do not exclude each other. One finding from the Deloitte survey in the United States stands out: 92 percent (Deloitte) of buyers currently using EDI plan to shift partially or fully to other channels. At the same time, nearly 90 percent (Deloitte) of B2B suppliers are upgrading their ERP or preparing to - a good moment to plan the interfaces for agents right away instead of retrofitting them later.
| Channel | Who triggers the order | Where approval sits | Fits for |
|---|---|---|---|
| AI research | a person with an AI assistant who then orders personally | with the person in the shop or the purchasing system | first-time needs, new customers, supplier comparison |
| Punchout and OCI | buyers from within the customer's purchasing system | in the customer's purchasing system | large customers with their own procurement system |
| EDI | the customer's ERP with fixed message formats | at the customer before the order message is sent | fixed partners, high volumes, stable assortments |
| Agent via API or protocol | software acting for the customer, flexible per need | in the shop by rules per agent or by mandate | reorders, C-parts, standard items |
- Does the customer have its own purchasing system with an approval process? Then punchout remains the shorter path, and an agent works better inside the customer's purchasing system than in the shop.
- Does the customer regularly order the same items directly from its ERP? Then EDI or a fixed interface does the job, and an agent adds little.
- Do needs, quantities and the people ordering change frequently, without a purchasing system in between? Then the agent channel with rules in the shop is the right path.
What a fixed partner connection looks like in the shop is shown in our article on EDI in the B2B shop.
Common Mistakes: Where Agent Projects Fail
Gartner expects more than 40 percent (Gartner) of agentic AI projects to be canceled by the end of 2027 - due to escalating costs, unclear business value or inadequate risk controls. In the shop, the causes usually show up in a few recurring places:
- Shared access: the agent uses an employee's password, every order looks like a human one, and a lockout hits both.
- Admin API instead of Store API: an agent with administrative rights reaches other customers and prices; for orders the customer account context is enough.
- Limits only in the agent: whatever is configured solely in the agent software no longer applies once the agent is replaced or compromised.
- Guest checkout in B2B: without a logged-in customer account, customer prices, payment terms and cost center are missing.
- No idempotency: repeated requests after a timeout create duplicate orders.
- Tools without their own checks: the Store API server for the Model Context Protocol has no Admin API permission check, the boundary is the sales channel context - every custom tool has to validate its input and data access itself (Shopware documentation).
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 the agent protocols. Since suppliers in the Deloitte survey trail buyers in using agents and Gartner expects 90 percent (Gartner) of B2B buying to be intermediated by agents by 2028, 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, with batch queries
- Prevent duplicate orders: introduce idempotency keys for order and approval calls
- Introduce agent identities: dedicated, revocable access within the customer account instead of shared credentials
- Define approval rules: set cost center, product groups, per-order and monthly budgets, and approval levels
- Extend the framework contract: agree on attribution, correction window and blocking duties for the agent channel
- Interlock ERP and PIM and stay connectable: keep prices and stock in sync, dock protocols 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.
Idempotency-Key header, which the Internet Engineering Task Force is still working on, is a good fit.Related Articles
Variant Matrix in the B2B Shop: Sizes and Colors in One Go
A variant matrix lets B2B buyers order sizes and colors in one table: stock per cell, tier pricing across the total, a mobile list. What Shopware CE offers.
Black Week in Your B2B Shop: Deals for Business Customers
Black Week in a B2B shop: when the German 30-day lowest price rule applies, what unfair competition law requires and how to limit deals in Shopware CE.
Pre-Orders in the B2B Shop: Sell Seasonal Goods Early
Pre-orders in the B2B shop: order windows and delivery dates per seasonal item, valuta from delivery, minimums, cut-off dates and ERP handover on Shopware CE.