Your browser doesn’t support HTML5 audio
How do you turn agent-legible capabilities – and the agents that consume them – into a profitable business? That’s still an open question as we stare into the abyss of the accelerating trend towards agentic systems.
And so while the announcement of Salesforce Headless 360 was the thing that most caught my eye at TDX this week – because of its deep implications for both Salesforce and its clients – there was one other less strident launch that felt equally important in the firm of AgentExchange, which, in simple terms, consolidates Salesforce’s existing marketplaces under one roof, while adding agents and related capabilities.
Because if Headless 360 is the foundation that turns Salesforce into a set of composable, agent-legible capabilities, AgentExchange is the thing that turns those capabilities into commercial reality – for Salesforce, its partners and its customers.
On the face of it, AgentExchange looks like a simple tidy up – a consolidation of loose threads and an effort to build a single storefront for brand purposes. After all Salesforce has been running its AppExchange marketplace for years, and that’s what many people will have taken away from the announcement
But in the context of Headless 360, it starts to look like something more deliberate. Because if Headless 360 is the operating model shift that enables the creation of useful agents, then AgentExchange is how those capabilities and agents can be offered and reused in practice.
It is, in effect, the mechanism for modular capabilities and specialized agents to be reused, whether they are provided by Salesforce or a third party.
Crucially, it does this in a way that makes that re-use economically viable. Not just discoverable, but sellable, billable, and worth building in the first place. In that sense, AgentExchange is not just a distribution channel, but an attempt to establish a financial transaction layer for the agentic enterprise – one that aligns incentives across builders, platforms and consumers.
But what’s quietly profound about AgentExchange is not the storefront, or even the commercial infrastructure behind it - it’s how it changes when, where, and by whom the decision to build on the expertise of others can now be made.
The just-in-time enterprise
The reason for this is that AgentExchange is not positioned as a destination. It is instead positioned as an embedded capability within the AgentForce platform. One which surfaces useful agents, tools, skills and connectors directly inside the AgentForce build experience.
Which means they are available at the exact moment that people are trying to compose a workable solution. And in doing so it encourages teams to move faster by building on what already exists – by enabling teams to discover, evaluate, select, purchase and activate those capabilities without ever leaving the context in which they are building.
And while that sounds like a usability improvement – the implications run much deeper.
Because what Salesforce is actually doing here is creating an operating model that encourages specialization by eliminating the friction of reusing capabilities – compressing the lifecycle from discovery to activation. Crucially, it collapses the act of buying into the moment of building – taking the lessons from AppExchange and applying them to disaggregated, composable, and agent-legible capabilities with a viable commercial model behind them.
This is effectively a shift toward a just-in-time model of capability consumption, where external services are pulled into the system at the moment they are needed, rather than provisioned in advance.
Which creates the opportunity to accelerate delivery – but only if the organization also distributes the authority necessary to facilitate that speed.
Which for most enterprises is far away from the reality today.
Computer says no
Since the dawn of time, enterprise software has been organized around the glacial pace of centrally governed procurement and financial processes. Identify a need. Evaluate vendors. Negotiate terms. Yawn. Procure the solution. Integrate it into the estate. Yawn (sorry). And then – finally – use it. Maybe.
And all of this is usually facilitated and governed by byzantine procurement rules and financial controls – often created with the aim of making life easier for procurement teams by minimizing supplier numbers, rather than maximizing the chance of solving the problem.
But as we rewire operating models to enable teams to move at agentic pace, this mismatch between the speed of build and selection, and the drag of centralized approval processes, can’t hold.
In effect, solving operating model debt in one place – by giving people more agency to build at speed – simply makes other parts of that same debt pop up elsewhere. And when building takes minutes and integrating takes seconds, procurement shouldn’t take months.
Yet, in most organizations, it still does.
From function to friction
What AgentExchange exposes, therefore, is a misalignment between the speed at which technology can now be assembled and the speed at which organizations are able to approve decisions about the consumption it requires to operate.
This is the part that is easy to miss when looking at these announcements in isolation. Headless 360 reduces the friction of exposing capabilities. AgentExchange reduces the friction of discovering and activating them.
But what remains in most enterprises are the practices and processes that always sat around those capabilities – procurement, governance, budget control – many of which were designed for a world in which integration was slow, expensive and infrequent.
As that assumption breaks down, so do the structures built on top of it – but not all at once.
Because this kind of operating model debt doesn’t show up in visions or strategy documents. It only becomes visible when teams start working in new ways – and suddenly find themselves constrained by decisions, controls and processes that were never designed for that mode of operation, which is why transformation tends to spiral outward from the point of initial use.
Agents accelerate the pace at which work can be configured and executed, and in doing so they expose the parts of the organization that cannot keep up. At first this shows up as small frictions – approvals, delays, workarounds – but as those frictions accumulate, they begin to define the limits of what the new model can actually deliver.
And that is where the real question sits. It's not whether the model implied by AgentExchange works, but whether organizations are capable of absorbing it, because the speed and composability it offers can only hold when the incentives to share are matched by the authority to act.
Because without de-centralization – the ability for teams to make decisions at the point of need – everything slows down again and the model struggles to move beyond experimentation. Effectively teams can build and experiment inside the tool – but must step outside and wait for permission to keep what they’ve built.
In that scenario, capabilities like AppExchange become little more than a discovery layer for experimenting with third-party services – but still hit the same old walls when teams need to move into production.
And while there is certainly value in that experimentation, it doesn’t seem credible that procurement timescales of months or years – facilitated by overloaded, centralized teams far away from the real work – can be allowed to stand in the way of practical value that can be deployed within hours.
My take
At its core, AgentExchange assumes that the people building systems are able to decide what those systems are made of.
We’ve seen similar principles before in debates around team autonomy and operating model design, but what is different here is that the assumption is directly embedded in the tools.
But that assumption doesn’t hold in most enterprises today.
And so the immediate role of AgentExchange is likely to be pragmatic rather than transformational – a way to explore, prototype and demonstrate value quickly, before handing off to more traditional procurement and governance structures to make things “official”.
But in doing so, it creates a new kind of pressure.
Because once teams can assemble working solutions in hours, the lag introduced by existing processes becomes explicit and increasingly difficult to defend. What previously felt like necessary control starts to look like delay, and what was once invisible operating model debt becomes a highly visible constraint on execution.
And looking into the longer term, if the cost of discovering, integrating and invoking external capabilities continues to fall, the implications may extend further. Capabilities no longer need to be owned to be used – they only need to be easily accessible, better than you could build yourself, and mutually profitable for all parties.
And once that becomes true in practice, the boundary of the organization begins to shift accordingly, from something fixed and internal to something more fluid and negotiated at the edges.
Something that looks like a real Agentic Enterprise, perhaps?