Salesforce's $3.6B Fin Deal: Why the Moat Is Integration

On June 15, Salesforce signed an agreement to buy Fin for about $3.6 billion. Fin, formerly Intercom, sells an AI customer-service agent. The detail worth stopping on: Salesforce didn’t pay for the model.

What $3.6 billion actually bought

Fin runs its own support model, called Apex. Salesforce says it outperforms top commercially available frontier models on support tasks. On paper, that reads like the prize.

But Salesforce already runs Agentforce, its own agent platform, and can plug in any frontier model it wants. A stronger support model was not what they were short on.

Look instead at what else came with the deal:

• More than 30,000 companies already paying for Fin
• An AI agent that resolves around 76% of support volume end to end
• Live across chat, email, WhatsApp, SMS, phone, and Slack

That is the expensive part. An agent already connected to where support happens, doing the work at scale, with outcomes customers already trust. Next to that, the model was the cheap part.

The smartest agent rarely wins

I’ve watched this pattern play out more times than I can count. A team ships an agent that reasons beautifully in a demo. Then it reaches production and stalls, because it can’t reliably reach the systems where the real work lives.

Picture a support agent resolving a single refund. It has to read the ticket, pull the order, check the refund policy, issue the credit, and post an update back to the customer. That is four or five different systems, each with its own auth, its own schema, and its own ways of failing. The model is identical whether that flow works or not. The wiring is what decides it.

Gartner put a number on the same idea. It expects 60% of AI agent deployments to fail, with integration as the reason, not model quality. And the jump from pilot to production usually comes down to agents lacking reliable access to the context spread across business systems, rather than a reasoning ceiling.

It gets worse than outright failure. When we tested thousands of agent tools, the most common problem was failures disguised as successes: an API returns HTTP 200 while the real error sits in the response body, invisible to the agent. The refund looks issued. The update looks posted. Nothing threw. The model never had a chance to notice, because the signal it needed never reached it. Getting that right across dozens of providers is slow, unglamorous work, and it’s most of what separates a demo from something 30,000 companies will pay for.

Fin had already crossed that gap. Thirty thousand paying customers and a 76% resolution rate describe an agent that survived contact with production. You can’t prompt your way to that, and a bigger context window won’t get you there either.

Distribution is the other half

The second thing $3.6 billion bought is distribution. Fin already sits inside tens of thousands of support stacks. Those live integrations and that track record would take years to rebuild, and most attempts would die in pilot before they got close.

This is the strategic shift every B2B SaaS platform is now facing. The old approach was “build into us”: partners and competitors integrate toward your platform, and you sit at the center. The new question is whether your own agent can connect outward across the systems your customers already run. Salesforce just paid billions for an agent that already does, and folded it into Agentforce.

Models are commoditizing. Connections aren’t.

Step back and the logic gets clearer. Frontier models keep converging on similar capabilities and getting cheaper. A support model that beats the field today is a lead measured in months. The part that doesn’t reset every quarter is an agent’s grip on real work: its live accounts and proven integrations.

That is the asset Salesforce protected with the price tag. It can rent raw intelligence whenever it wants. What it can’t rent is an agent’s accumulated connection to where work actually happens.

Why we think about it this way at StackOne

We build StackOne as the action layer between agents and enterprise systems, for exactly the reason the Fin deal illustrates. An agent’s value comes from the work it can reliably do across a business’s systems, not from which model sits behind it.

So we put the hard part in one place. One layer connects an agent to 310+ systems and 20,000+ actions across HR, CRM, support, documents, and finance, and handles the auth, schema mapping, and execution underneath. Swap the model next quarter and the connections still stand.

What this means if you’re building

If you’re shipping an agent, the Fin deal is a useful gut check. Two questions matter more than your model choice:

• Which systems does the agent actually need to touch to finish a task, and how reliable is that access today?
• If you swapped the model tomorrow, how much of your stack would you have to rewire?

If the honest answer to the second one is “most of it,” your architecture is betting on the layer that resets every quarter. Salesforce just spent $3.6 billion pointing at the layer that doesn’t.

If that is the layer you’re wrestling with, it’s the problem StackOne is built to handle.