Headless 360: Nearly Headless Nick, or Something More?

When Salesforce announced Headless 360 at TDX, the reaction in some corners of the ecosystem was a collective shrug. "Salesforce has had APIs for 20 years. MCP is just a new kind of head, not the absence of one. This isn't that big a deal."

I get it. I really do. And that critique isn't entirely wrong.

But I think it misses something important — and I've been turning it over since I got home from San Francisco.

What Headless 360 Actually Is

The name is doing a lot of work, so let's start with what Salesforce actually announced.

Headless 360 is a platform reframing: everything in the Salesforce stack — the CRM data, the business logic, the agent capabilities, the trust layer — is now packaged as APIs, MCP tools, and CLI commands that can be accessed without a Salesforce UI. The demo showed a React application built natively on Salesforce infrastructure; an Agentforce service agent deployed simultaneously across Slack, Microsoft Teams, mobile, and ChatGPT; and third-party tools like Claude Code and OpenAI agents running inside the Agentforce harness — all talking to the same underlying platform.

The keynote framed it as: define your experience once, then deploy it everywhere your customers actually are.

Why the Skepticism Is Fair

The critics aren't wrong on the facts. Salesforce has had APIs for over 20 years. MCP is new as a standard, but the concept of accessing Salesforce programmatically without the Lightning UI is not. And the claim that "everything on Salesforce is now an API, MCP tool, or CLI command" is, let's be honest… optimistic.

If you've lived through a Pardot implementation, or you're still managing Marketing Cloud, or you came in through one of Salesforce's many acquisitions over the years — you know that the Salesforce platform is not one coherent thing. It's a collection of products with varying degrees of integration, some of which still require very much headed workarounds. Headless 360 does not change that overnight.

So yes. Nearly headless, in some meaningful respects. (Harry Potter fans, you know who I'm thinking of. 👻)

But Here's What the Critique Undersells

The skeptic framing treats this as "just APIs with a new name," and I think that's too quick.

What's actually new isn't the existence of APIs. It's the standardization layer — specifically MCP — and what that standardization makes possible for agent interoperability.

Before MCP became a shared protocol, every integration was its own custom bridge. You could access Salesforce from an external tool, but you had to build a bespoke connection every time — and every connection was unique to that specific pairing. Think of it like a jigsaw puzzle: the pieces only fit one way, by design. The trust and security context didn't travel with the call. Agents from different vendors couldn't easily collaborate because there was no shared language for describing what they could do or how to invoke each other's capabilities.

MCP changes that by making the tooling composable — meaning you can assemble agent capabilities from interchangeable, independently-built pieces rather than being locked into one vendor's complete bundled solution. Now it's Lego bricks instead of a jigsaw puzzle. Repeatable standardization, not bespoke fittings. A developer can use Claude Code or OpenAI agents or Agentforce's native tooling, and they all reach the same underlying Salesforce data through the same shared interface. APIs let you access things. MCP makes things interchangeable.

What I watched in the TDX keynote demo was something I haven't seen before: a Claude Code agent and an OpenAI agent running inside the same Agentforce harness, drawing on the same Salesforce metadata and trust layer, choosing the right tool for the right task. That's not just "APIs." That's the beginning of a world where your Salesforce org isn't a destination you log into — it's a capability layer that any qualified agent can access, regardless of who built it.

One phrase from the demo stuck with me: "Choose your tool. What we have done is we have packaged them all." Sixty-plus MCP commands, 30-plus pre-built skills, available from Claude Code, Codex, Cursor, or anything else that speaks MCP. The packaging and standardization is the new thing — not the APIs themselves.

Why This Matters More Than It Looks

Think about the organizational reality most Salesforce customers are living in right now.

They have Salesforce. They also have Microsoft tools. They probably have at least one point solution that doesn't play nicely with either. And they're about to be inundated with agent offerings from every direction — from Salesforce, from Microsoft, from niche vendors building vertical-specific capabilities.

The question that's going to define the next three years of enterprise AI isn't "which agent should we use?" It's "how do we get agents from different vendors to work together without building a custom integration for every single connection?"

MCP is, at this point, the closest thing to an answer the industry has produced. And Headless 360 is Salesforce's bet that if they package their entire platform — all that CRM data, all that business logic, all that trust infrastructure — as first-class MCP endpoints, they become the data layer that other agents want to work with. Not just Agentforce agents. Any agent.

That's a genuinely interesting strategic move. And it's different from "we have APIs."

The "Nearly" Part Still Matters

I don't want to overclaim. If your Salesforce environment is built on products that weren't architected for this kind of composability, Headless 360 is a direction, not a solution. The acquisition-integration debt that's been accumulating for years doesn't disappear because MCP exists.

And "define once, deploy everywhere" is a vision that will take time to fully deliver on. The demo was impressive; production enterprise deployments are harder.

There's also a practical cost question worth watching: MCP tool definitions load into the context window at the start of each agent session, so the LLM knows what capabilities are available. With 60-plus MCP commands in the catalog, that's real token consumption before the agent has done anything useful. In a consumption-based pricing model — which, notably, is exactly where Salesforce is moving — that overhead compounds fast at scale. There are partial mitigations (I bet you can scope an agent to load only the tools relevant to its specific role rather than the full catalog), but this is an evolving area and the "package everything" framing from the keynote glosses over the cost implications. If you're planning implementations around this, it's worth pressure-testing your usage assumptions before you commit to a pricing model.

But here's the thing about our nearly headless ghost: he's still a ghost. He still moves through walls. He still shows up at the feast. Being nearly headless didn't stop him from functioning — it just kept him out of the Headless Hunt.

Headless 360 isn't finished. But it's pointing in the right direction, and the standardization it represents — particularly around MCP and multi-vendor agent interoperability — is worth taking seriously even if the rollout is uneven.

The organizations that start thinking now about how their Salesforce environment can serve as a composable capability layer for agents — not just a system their people log into — are going to be in a much better position when this matures.