Accountability Doesn't Come From Counting Vendors

By Everett Zufelt, Program Lead, Agent Ecosystem, MACH Alliance

Composable made the seams visible. Agents will multiply them. Here's the operating model that outlasts both.

Somewhere in every evaluation of composable commerce, a leader asks the question that really matters to them, usually more quietly than the rest: when something goes wrong, who do I hold accountable?

It's a fair question, and a revealing one. An enterprise commerce solution is never one thing. It's an assembly of customer data, content, search, cart, payment, tax, shipping, loyalty, fraud, and the systems feeding all of them, drawn from many vendors, partners, and internal teams. Composable architecture, the practice of building that solution from best-of-breed services connected by APIs rather than buying a single suite, makes the assembly explicit. Suddenly you can count the parties, and the count is unsettling.

It's about to get much larger. The agentic era, where software no longer just follows fixed steps but decides and acts on your behalf, is taking the number of moving parts from the dozens of composable into the hundreds and beyond. The instinct is to manage the worry by counting and controlling the parties. That instinct fails exactly when you need it most, because the count only goes one direction.

You were never able to buy or outsource a single point of accountability. It was always you. The monolithic suite that promised one vendor and one number to call was, underneath, its own crowd of integrators, hosting providers, and gateways. Accountability has never come from owning or counting the parts. It comes from a handful of principles the accountable party controls, and those continue in to the agentic era.

The single point of accountability was always a myth

Rewind to the monolithic suite, the all-in-one platform sold on the promise of one vendor and one phone number. Underneath the badge it was still systems integrators, customization partners, hosting providers, payment gateways, and your own team. When a launch went sideways, the suite vendor pointed at the integrator, the integrator pointed at the customization, and everyone pointed at "the integration." The boundaries were blurry, so resolving who owned the problem took longer, not less often. Homegrown and DIY stacks were a different flavor of the same trap: accountability was technically all yours, which without the right discipline is its own kind of nowhere.

So composable didn't create the accountability problem. It made the seams visible. That sounds like a downgrade. It's the opposite: visible seams are far easier to govern than hidden ones, because you can see exactly where one party hands off to the next.

Agents turn a manageable problem urgent

Then come agents. Where composable involves tens of parties, the agentic era points toward hundreds and eventually thousands of semi-autonomous actors calling tools, requesting data, and triggering one another across your systems and your partners'.

A blame-resolution process that depended on getting five vendors onto one call does not survive contact with a agentic thousand actors moving in milliseconds. If your answer to "who is accountable?" rests on counting and corralling the parties, it stops working at the scale the market is heading toward.

Accountability comes from five things you control

The good news is that the answer hasn't changed in decades. It comes from five disciplines that hold regardless of how many vendors, partners, or agents are in the solution. Treat them as an operating model, not a procurement checklist.

Define what good looks like. You can't hold anyone to a standard you never set. That means service-level agreements, or SLAs: the uptime and response commitments each vendor signs. It also means the non-functional requirements, the NFRs, that rarely reach a contract, such as how fast checkout must load, how the system behaves on the busiest day of the year, and what happens when one service stops responding. Good is a number, written down, agreed before the incident.

Measure against it. Observability is the ability to see what your systems are actually doing in production, end to end, rather than inferring it from the outside. It turns "the site feels slow" into "the tax service is adding 800 milliseconds to checkout." It's now standard practice rather than a luxury: and it can be implemented for front-end experiences, back-end infrastructure, and agents.

Know the moment it slips. Set the thresholds that matter to the business and alert on them automatically, so you learn that a payment provider is degrading from your own monitoring rather than from customers on social media.

Trace it to the source. When something breaks, traceability lets you follow a single request across every service it touched and find where it failed. This is what ends the finger-pointing, because you arrive with evidence instead of opinions.

Name who owns the fix. Every component, integration, and agent needs a named human accountable for it. Tools don't create accountability. People do.

The accountable party already exists. It's you.

Notice who all five of those disciplines belong to. Not a vendor. You.

There has realistically always been a single accountable party for an enterprise commerce solution, and it lives inside your brand. You can delegate the work to a system integrator, and many brands should. But accountability for the whole doesn't leave with the statement of work. The integrator operates the five principles on your behalf to keep the solution secure, reliable, and performing; the answerability stays with you. That distinction is easy to blur and expensive to forget, usually at the worst possible moment.

None of this is glamorous, and none of it is new. It's the unflashy discipline that always separated the teams who thrived on complex solutions from the teams who drowned in them, long before composable had a name. What composable changed was to make that discipline non-optional, by making the seams visible. What agents will change is the urgency, because the parts will multiply faster than any manual process can track.

So when someone asks who you'll hold accountable when something goes wrong, give the honest answer: you will. Stand the operating model up now, while the parties still number in the tens. You'll be glad of it when they number in the thousands.