TL;DR
- Salesforce Headless 360 opens up the entire platform to agents via APIs, MCP tools, and CLI commands — but access alone doesn’t equal understanding
- Without a shared system of context, every agent rebuilds a partial, error-prone picture of the org, turning ambiguity into real cost under consumption-based pricing
- The missing layer is a deterministic, queryable view of the system itself—a context layer — which is where Sweep operates
*****
At TDX last week, Salesforce announced Headless 360.
Sixty-plus MCP tools.
Thirty-plus coding skills for Claude Code, Cursor, Codex, and Windsurf.
The Agentforce Experience Layer rendering one agent across Slack, Voice, WhatsApp, and ChatGPT. Agent Fabric for multi-vendor orchestration. Consumption pricing replacing per-seat. Parker Harris, on stage, asking why anyone should ever log in to Salesforce again.
If you've been in the Salesforce ecosystem for more than a few release cycles, you already know what this means in practice. Every architectural shift lands on a platform that wasn't fully documented to begin with, and every rename breaks automations that nobody had a current map of.
It’s the most ambitious move Salesforce has made in 27 years. It's also the right one. The Salesforce UI was never the moat. The metadata was. Headless 360 is Salesforce saying that out loud, proudly even.
To that I say: good for them. And good for us.
That argument is finally over. Here's the point that starts next.
An API surface is not understanding
Every enterprise Salesforce org is a unique graph of metadata, permissions, automations, and accumulated intent built up over years. No general-purpose agent, however capable, can reason about it without proper grounding. Headless 360 gives an agent the ability to call any capability on the platform. It does not tell the agent what calling that capability will do.
It’s a different job, at a different altitude on the stack.
Three things in the Headless 360 announcement make this more obvious than Salesforce's own framing admitted.
Agent Script is a confession
Jayesh Govindarjan, the EVP who architected Headless 360, told VentureBeat that early Agentforce customers got agents into production through "sheer hard work" and then were afraid to change anything. One tweak, the whole thing might break. Agent Script is the answer: a DSL that wraps LLM reasoning inside a state machine, versionable, auditable, open-sourced. It's a good answer. But notice what it governs. It governs what the agent does. The steps. The funnel. It does not describe what the agent is acting on. It assumes the substrate is coherent. For most real Salesforce orgs, that assumption is the whole problem.
The MCP hedge tells you where the puck is heading
Govindarjan also said he's "not at all sure" MCP will remain the standard. A lot of engineers think MCP is a wrapper on a well-written CLI. So Salesforce is shipping all three — API, CLI, MCP — and letting the market decide. That's honest. It also tells you where not to invest. Protocols churn. Access patterns churn. What doesn't churn is the semantics of what's in the org — the fields, the flows, the Apex, the dependencies, the permission topology. Anything built above the protocol fight, on the context itself, gets more valuable every time the access pattern changes.
Consumption-based pricing is the biggest tell
Agentforce moved from per-seat to consumption. When agents do the work, per-user pricing stops making sense. A (second-order) consequence: the cost of bad context just went up. Every agent loop that fires on ambiguous metadata, every retry triggered by a duplicate field, every dead-end traversal through an orphaned automation — that's a metered line item now. Incoherence has arrived to the invoice.
Every agent is rebuilding org context from zero
Here's what's happening in enterprises as they deploy Headless 360 and Agentforce today. A developer opens Claude Code, points it at the Salesforce MCP, and spends the first half hour of the session watching the agent try to figure out what's in the org. Another developer opens Cursor, points it at the same MCP, and watches the same process from scratch. Agentforce spins up an agent that reasons over what it can see in Data 360. A fourth team builds a custom agent with the OpenAI SDK and goes through the same discovery loop a fourth time.
Four agents. Four independent, partial reconstructions of the same org. Every one of them susceptible to the same class of mistake: reasoning about a field that was renamed two quarters ago, a flow that's been disabled but not deleted, a permission set that grants access nobody realized was exposed.
Salesforce has shown demos where Agentforce deployments failed because an agent assumed a field existed that didn't actually. That's not a bug you can fix by adding more MCP tools. It's the natural consequence of giving agents a surface to call against without giving them a system to reason about.
What a context layer actually is
A context layer is a deterministic, continuously indexed graph of what's actually in the org right now — every object, field, flow, Apex class, validation rule, and permission — with the dependencies between them mapped and queryable.
Agents don't infer it. They query it. Every agent, every tool, every coding assistant draws from the same source of truth, in real time.
That's the layer Sweep has been building. Three things it does that an API surface, on its own, structurally cannot:
Understand — a live Metadata Graph, process intelligence across flows and Apex, and usage intelligence that distinguishes active configuration from dead weight. Agents stop reasoning about what might be in the org and start querying what is.
Act — grounded construction through Build Mode, cross-platform awareness so agents can reason across systems rather than only inside Salesforce, and a single MCP interface that any agent — Claude, Cursor, Copilot, proprietary — can share.
Govern — impact preview before every change (what breaks, who's affected), permission topology that surfaces exposure before it becomes an incident, and continuous monitoring of drift and agent-driven activity over time.
The shift is simple. Without a context layer, execution happens and consequences surface later. With one, consequences surface first and execution is informed. Agents don't get slower. They get accurate.
Sweeping it all up
Headless 360 gave agents the API. It's going to accelerate what enterprises can do with Salesforce in ways that are difficult to overstate. But agents are only as smart as the context they have.
Right now, most enterprises are handing their agents a surface of verbs and asking them to improvise the rest.
And while Parker Harris asked why you should ever log in to Salesforce again, the better question is what the agents should understand about your org before they log in for you.
Salesforce made the platform programmable and the context layer is what makes it intelligible.
