The missing layer in B2B agentic commerce.
Every few weeks the agentic commerce conversation takes another lap, and the laps are getting predictable. The retail camp describes a near future where a shopper tells an assistant "find me running shoes under $120" and the agent discovers, compares, and buys. The B2B camp — rightly — pushes back: that's not how we work. B2B doesn't start with open-marketplace discovery. It starts with a relationship, a signed contract, negotiated pricing, and an approved supplier list. The buyer already knows who they're ordering from. The agent's job isn't to find a vendor; it's to act inside an agreement that already exists.
That correction is a good one. It's also where almost every article stops.
Once you accept that B2B agents execute within existing agreements, the interesting question is no longer whether agents will negotiate. They will. Forrester is already forecasting that within the year a meaningful share of sellers will be answering buyer-side agents with their own seller-controlled agents, delivering dynamic counteroffers in real time. Gartner expects the majority of B2B revenue to run through digital channels by 2028. The direction isn't in dispute.
The question nobody is answering is the one that actually decides whether any of this ships:
When the agent says yes, what turns that "yes" into a real transaction?
Negotiation is the easy part
This is going to sound backwards, so let me be specific about why it isn't.
A negotiation is a conversation. Conversations are exactly what large language models are good at. An agent reading a sourcing request, weighing options, and proposing terms is squarely in the model's comfort zone — it's probabilistic, it's linguistic, and a slightly-off answer is recoverable because a human or another agent can push back before anything is committed.
Execution is the opposite kind of problem. Committing a B2B transaction against a negotiated agreement is not a conversation. It's a sequence of deterministic operations that either all succeed correctly or leave you with a mess to clean up:
- Resolve the right account, contract, and entitlement set for this buyer — not a buyer like them
- Apply the negotiated rate plan, including volume tiers, ramp schedules, and any account-specific overrides
- Calculate proration, co-terming, and the dollar impact of a mid-term change before anything is written
- Run tax, fraud, and credit checks against live rules, not last quarter's
- Provision the actual entitlement the moment the order is accepted
- Bill it correctly, on the right cycle, with an audit trail a finance team will sign off on
None of that is a vibe. There is exactly one correct outcome, and "approximately right" is indistinguishable from "wrong" the moment it hits an invoice. You cannot probabilistically guess a customer's contracted price and hope the model rounds in your favor.
So the real architecture of B2B agentic commerce isn't one intelligence doing everything. It's a division of labor: the agent proposes, and a deterministic layer commits. The agent handles the part that's linguistic and flexible. Something else has to handle the part that's exact and irreversible.
That something else is the layer almost no one is writing about.
Build-time agents vs. run-time execution
Here's where most of the current tooling quietly breaks.
A lot of "agentic" commerce capability being announced today is built at design time. You describe a flow, the agent helps you assemble it, and what gets produced is a configured experience — a checkout, a quote path, a self-service journey — that then runs the way it was authored. The intelligence lives in the building. The thing that ships to the buyer is static. When the buyer's situation doesn't match the flow you authored, the flow doesn't adapt; it fails, or it routes to a human.
That's a build-time agent. It's useful, and it's the wrong primitive for what's coming.
What B2B actually needs is intelligence at run time — the moment the buyer (or the buyer's agent) shows up with a specific account, a specific contract, and a specific request. The system has to interpret that request, ground it in the buyer's real agreement, calculate the genuine impact, and execute against the billing engine, all in the live transaction, without a human pre-authoring the exact path. The agent is the interface. The execution layer is what makes the interface safe to act on.
Bolt an agent onto a build-time stack and you get an impressive demo and a dangerous production system. The failure modes are familiar to anyone who has run a billing migration: silent charge drops when a catalog field doesn't map, entitlements provisioned that were never actually paid for, proration that's off by a cycle, a "successful" order that finance can't reconcile three weeks later. The agent looked smart. The transaction was wrong. And in B2B, a wrong transaction isn't an abandoned cart — it's a contract dispute.
The part you can't fake with twenty years of scar tissue
I've spent two decades implementing billing and revenue systems for enterprises where a misapplied rate plan was a board-level conversation. The lesson that experience drills into you is unglamorous: the hard part of commerce was never the front end. It was always the run-time correctness of what happens when someone commits to pay.
Agentic commerce doesn't change that. It raises the stakes. We're about to put a fluent, confident, tireless interface in front of the exact subsystem that punishes confidence without correctness. A buyer-side agent will ask for a mid-term upgrade with a custom term, and something on the seller side has to either execute it exactly right or refuse cleanly. There is no third option that survives an audit.
This is why I think the industry's framing is one level too shallow. The race isn't to build the smartest negotiating agent. That capability is going to commoditize fast — it's a conversation, and everyone will have one. The durable advantage is the layer underneath: the run-time engine that can take an agent's "yes" and turn it into a provisioned, billed, reconcilable transaction against a real contract, deterministically, every time.
In B2B, the agent is the interface. The execution layer is the product.
If you're a B2B company sizing up agentic commerce, the most useful question to carry into every vendor conversation isn't "how good is your agent?" It's "what happens after your agent agrees to something?"
Push on that, and the field separates quickly. Some answers will be a confident demo. The ones worth your time will be able to walk you through proration, entitlement provisioning, tax, and the audit trail — the boring, deterministic machinery that decides whether agentic commerce is a real channel or an expensive way to generate disputes.
Negotiation is the headline. Execution is the business. The companies that win the next phase of B2B commerce won't be the ones with the most articulate agents. They'll be the ones who built the layer that can be trusted to act when the agent says yes.