Composable was step one. What comes next?

Composable architecture gave enterprises the foundation to move off rigid platforms and onto modular systems, unlocking agility, scalability, flexibility and resilience. We believe the next generation of commerce and of the broader software industry sits on top of two pillars: (1) agentic orchestration and (2) on-the-fly, highly personalized experiences for the people who use it.

For most of the last decade, the hardest question in enterprise commerce was an architectural one: How do you prevent a single vendor from owning your roadmap? Composable answered it. 

Breaking the monolith into API-first, swappable parts gave enterprises something they’d never had: The freedom to assemble the stack they wanted and change any piece of it without tearing down the rest.

That freedom was real, and the industry moved in that direction. But architecture decisions send their bills to unexpected places. Composable’s arrived on the desk of the person nobody designed it for: The one running the business day-to-day.

A quick recap on composable architecture and its impact on the commerce industry

Composable did three things that changed commerce. It decoupled the frontend from the back, so a brand could ship a new experience without waiting for a platform release. It made best-of-breed possible, so teams could choose the strongest PIM, the strongest CMS and the strongest search, instead of accepting whatever came bundled. And it put an API in front of everything, so commerce could reach any channel a customer might show up on.

For the CTO and the architect, this was the right answer, and it still is. The trade-off is that composable is optimized for technical flexibility, and technical flexibility is not the same thing as operational ease. Every best-of-breed component arrived with its own back office, its own login, its own mental model. The marketer running a single campaign now has to work across five interfaces to do it. The architecture created agility at the API level and fragmentation at the human level.

The interface layer made it worse. Across the category, the back-office tools business users live in were an afterthought. Every best-of-breed component shipped its own admin screens, built for configuration rather than for the daily work of running a business, and no one owned the experience that tied them together. The plumbing got a decade of investment. The experience on top of it did not.

At the same time, while the traits of composable augmented the cost and fragmentation for the business user, the same characteristics are what make the autonomous era possible. An agent can only act on what a system exposes, and a composable stack exposes everything: Every capability sits behind an API, individually addressable, and exists without a single vendor owning the entire stack. That’s the substrate agentic systems need, and composable architectures are built for it.

What is agentic orchestration and its transformative impact on commerce operations

Agents are what run on top of the infrastructure. An agent is a piece of software that takes a goal, decides how to reach it, and acts through the same APIs a person would. One agent is useful. A dozen agents working in isolation just reproduce the problem composable left behind: Capability everywhere, coordination nowhere. Agentic orchestration is the layer that makes many agents behave like one coherent system.

An agent orchestrator removes it by doing what that person does. Give it a business intent (“set up a BOGO promo for skincare in DE and FR starting Friday”), and it decomposes the intent into a plan, routes each task to the agent best suited to it, passes context between them so the promotion agent knows what the catalog agent found, and synthesizes the results into one coherent answer. It also handles the messy parts: “Promotion is ready, but two SKUs are low on stock in FR. Here are your options.”

Here is the part only a composable platform can claim. A real stack is heterogeneous. Some agents are first-party, built by the platform and grounded in its system of record; many are third-party, the customer’s own tools. Orchestrating across both requires a layer that favors no single ecosystem. This is where the incumbents break down. Shopify’s Sidekick, Salesforce’s Agentforce and SAP’s Joule each pull coordination toward their own walls. A neutral layer doesn’t. And because the first-party agents are grounded in real commerce data (live catalogs, pricing, inventory, orders), they return facts, not plausible fiction.

Done well, the coordination tax disappears: The campaign that once sprawled across five tools and an afternoon becomes a single request and a result to review.

On-the-fly, personalized experiences as a new way to engage with software

The orchestrator does its work out of sight. It coordinates the agents, queries the systems, reconciles the answers. But coordination is only half the problem. The person still has to see something, decide and act.

Today, a user navigates a fixed interface and inputs commands to get a result. The interface is the input. We think it becomes the output instead. You state what you’re trying to accomplish, the system does the work, and the interface is what comes back: An overview of what happened, what needs your attention, and what to decide next, assembled around that specific intent.

For example, a merchandiser types “show me how our spring collection is performing in the UK.” What returns is not a dashboard she has to filter down. It's those products, that market, those metrics, with the relevant actions sitting right there: Extend the promo on the top sellers, adjust pricing on the laggards. 

An ops manager asks which orders are at risk of missing their delivery window this week and gets exactly those orders, each with the reason it's slipping and one-tap options to reroute, expedite or notify the customer. Behind that single view, the orchestrator may have pulled from five systems. The user touches none of them. The five-tool problem doesn’t get solved by replacing the tools. It dissolves because nobody has to open them anymore.

This is not a chatbot bolted onto a dashboard. The interface itself is generated, tailored to the task and the role.

Where do we go from here

Composable solved the architecture. It made commerce modular, addressable and free of any single vendor’s gravitational pull. What it didn’t solve was the work that happens on top of that architecture: The coordination that fell to people, and the interface that was never built for them. The two pillars are how that work gets finished. Agentic orchestration takes over the coordination. On-the-fly experiences take over the interface. Neither was possible before. Both are possible now, because the stack underneath them is composable.

That's the work we’re making at commercetools, and it has a name: Autonomous commerce orchestration. The product behind it is MosAIc, an orchestration layer that sits across your full stack, coordinates first and third-party agents against your real commerce data, and composes the interface around what you’re trying to get done.

This is the start of our series, the Build Log showing the work as it happens: The architecture decisions, the trade-offs we’re weighing, the things that break and what we learn from the design partners building the first workflows with us on their own stacks and data. Some of it will be polished. Some of it won’t. That’s the point of building in public.

Stay tuned for more. We just got started!