Investor brief · Headless 360
Salesforce's Headless 360 (TDX 2026) is the umbrella idea that every Salesforce capability is reachable as a REST API, an MCP tool, or an A2A agent — no LWC, no browser, agent-readable end to end. Pause was built into that pattern from the start: Data 360 grounding (REST), the MCP server + host (MCP), and the A2A Care Router (A2A) are all live. This page is the cross-surface audit so a reader can tell at a glance what Pause already does, what's wired-but-gated, and what's still missing for full Headless 360 conformance.
The three Headless 360 patterns
Salesforce's pattern guide (blog post) frames Headless 360 around three integration patterns. The short version: REST is the classic substrate, MCP is the agent-readable contract, A2A is the cross-agent handshake. Pause is in all three.
The classic Salesforce integration substrate. In Headless 360, REST is still load-bearing: Data 360 grounding queries, Apex callouts, Tooling API, Bulk API, Connect API. Pause's prototype exercises this pattern through the Data Cloud connector and the MuleSoft Experience APIs.
60+ Salesforce-hosted MCP tools (per the TDX 2026 announcement) plus the MuleSoft MCP Bridge. Headless 360 makes MCP the agent-readable contract for Salesforce capabilities — same idea as the public MCP registry, scoped to Salesforce. Pause is both an MCP server (exposing its four Pause tools) and an MCP host (the Care Router calls find_menopause_providers as a tool, not a direct HTTP).
Google's A2A spec (JSON-RPC tasks/send with an Agent Card + OAuth handshake) is the cross-agent integration pattern in Headless 360. Pause already publishes an Agent Card and accepts A2A tasks/send for the Care Router; an upstream Agentforce Service Agent can delegate routing to Pause without leaving the A2A contract.
Surface map · Pause → Headless 360
Each row is a real surface in the Pause prototype today, mapped onto its Headless 360 pattern, with the actual identity model used (not the eventual PKCE flow — see the audit below for that gap). Status pills here are the same as the corresponding /proposal/* page each surface is documented on.
| Surface | Pattern | Identity / auth today | State | Pill |
|---|---|---|---|---|
| Data 360 (Data Cloud) grounding | REST | Service-user token (a360 exchange against SF_DC_TENANT_URL) | Live in production. Three Calculated Insights (HRV z-score, vasomotor burden, sleep disruption) authored over ssot__Individual__dlm. Returns 'Phase 2: SOQL (Health Cloud) + Data Cloud Calculated Insights' on /api/data-360/patient/[id]/grounding. | Shipped |
| Agentforce embedded chat | REST | Public deployment metadata (NEXT_PUBLIC_AGENTFORCE_*; no Connected App on the client) | Live when the four NEXT_PUBLIC_AGENTFORCE_* env vars are set. Embedded Messaging for Web v2 (Enhanced Chat). Already running the Pause_Health_Intake_Agent in the trailsignup org with the Find-a-Provider subagent. | Wired in prototype |
| Agentforce Voice | REST | CCaaS partner SDK (Amazon Connect Streams / Five9 / NiCE / Vonage) — Salesforce-side voice routing under existing Agentforce auth | Seam wired today; full activation gated on Agentforce Contact Center licensing + a CCaaS partner contract. /api/agentforce/voice/config and <AgentforceVoiceButton/> degrade honestly: designed → prototype → shipped driven by env vars. | Designed |
| MuleSoft Experience APIs | REST | Auth0 JWT → MuleSoft Flex Gateway → CloudHub 2.0 (production); mock fallback when MULESOFT_*_BASE_URL is unset | Live at https://pause-health.ai/api/mulesoft/{health,providers,patient/*}. Iteration 1–8 complete; iteration 9 (persistent VM hosting for the Flex Gateway) is the only remaining piece. | Shipped |
| MCP server (Streamable HTTP) | MCP | Unauthenticated against the public mock; bearer token via PAUSE_MCP_API_KEY in customer deployments | Live at https://pause-health.ai/api/mcp. Registry-callable by Agentforce 3.0 (Setup → Agentforce Registry → New MCP server). Lists 4 tools (timeline, intake, providers, health). | Shipped |
| MCP server (stdio) | MCP | Inherits parent process credentials (Claude Desktop / Cursor / Agentforce local connector) | npx @pause-health/mcp ships the same 4 tools over stdio. Tool definitions single-sourced from frontend/lib/mcp/tools.ts via a parity test. | Shipped |
| MCP HOST (Care Router calls external MCP servers) | MCP | Per-request MCP client; remote auth via PAUSE_MCP_HOST_REMOTES headers | Production-on at pause-health.ai (PAUSE_MCP_HOST_ENABLED=on). Care Router resolves provider recommendations by calling find_menopause_providers as an MCP tool against /api/mcp, not by direct HTTP. Loopback live; external slot empty until a partner MCP server is ready. | Shipped |
| A2A Care Router endpoint | A2A | Public unauthenticated demo; designed for OAuth-mediated identity propagation when a customer org binds it. | Live at /api/agents/care-router/tasks. JSON-RPC 2.0 tasks/send envelope with full A2A Task return shape (status, artifacts, history, agentFabric metadata). Agent Card at /.well-known/agent.json. | Wired in prototype |
The audit · What's missing for full Headless 360 conformance
Pause covers most of Headless 360 incidentally — three out of three patterns (REST + MCP + A2A) have at least one live or wired surface. The gaps below are the explicit Headless 360 invariants the prototype doesn't yet satisfy. Each is named here so it can be tracked, not hidden. As of 2026-06-27 all four read prototype — the code seams are in place; activation per gap requires the env-side procurement steps each needed column describes.
| Gap | Why it matters | What lands when activated | Pill |
|---|---|---|---|
| PKCE External Client App OAuth flow | Headless 360's trust model is OAuth 2.0 Authorization Code + PKCE via an External Client App, scopes `mcp_api` + `refresh_token`. The Pause prototype today consumes Salesforce surfaces under service-account or public-deployment identities — not under the end user's identity, which is what PKCE enables. | Shipped 2026-06-24 as a dormant seam. lib/salesforce-headless360.ts + the five routes under /api/salesforce/headless-360/* (config, authorize, callback, token/refresh, me, logout) implement the PKCE handshake with HMAC-signed session cookies. 25 unit tests pin the env-var parsing, the PKCE alphabet + S256 derivation, and the signed-cookie tamper-evidence invariants. Activate by setting SF_HEADLESS360_CLIENT_ID + AUTH_BASE_URL + REDIRECT_URI + SESSION_SECRET; see docs/HEADLESS_360_RUNBOOK.md for the External Client App procurement steps. | Wired in prototype |
| `mcp_api` scope on the Pause MCP server | Today the MCP server is unauthenticated against the public mock. Headless 360's MCP pattern expects the calling agent to present an OAuth token with `mcp_api` scope so the server can attribute tool calls to a Salesforce user identity for Event Monitoring and Shield audit. | Shipped 2026-06-27 as an env-gated middleware. validateMcpApiBearer in lib/salesforce-headless360.ts calls Salesforce's /services/oauth2/introspect (strict — verifies token is active AND scope contains mcp_api) with a /services/oauth2/userinfo fallback for orgs that disable introspect (permissive — verifies token aliveness only; result flags itself as `userinfo-fallback` so callers can log the weaker guarantee). Follow-ups landed same day: positive introspect results cached for 60s with a bounded LRU process-local Map (negatives re-check so freshly-issued tokens aren't stuck rejected), the validated identity threaded through the gate as X-Pause-MCP-User + X-Pause-MCP-Via response headers on every /api/mcp success, and a new GET /api/mcp/whoami diagnostic endpoint returning {gate: "on"|"off", via, username} so operators can verify the gate is wired correctly without parsing the SSE stream. The Care Router's MCP host (lib/mcp/host.ts) propagates the inbound bearer to the loopback remote only — never cross-origin to externally-configured MCP servers. 34 unit tests pin the introspect/scope/inactive/fallback matrix, the cache TTL + negative-no-cache + per-token-isolation behavior, the same-origin host guarantee, and the whoami diagnostic envelope. Activate by setting SF_HEADLESS360_REQUIRE_MCP_AUTH=on alongside the existing SF_HEADLESS360_* env (provisioned during gap #1 activation). The Agentforce 3.0 Registry public-mock posture stays the default when unset. | Wired in prototype |
| Agent Fabric → Salesforce Platform Event egress | Headless 360 leans on Salesforce Shield + Event Monitoring for governance. The Pause prototype already records spans on its own Agent Fabric trace surface, but doesn't yet ship them into the customer org. Note: Real-Time Event Monitoring's catalog (LoginEvent / ApiEvent / etc.) is Salesforce-platform-internal — external apps cannot define a new RTEM event type. The partner-supported pattern is publishing custom Platform Events, which the customer admin then routes into their audit pipeline (Transaction Security policies, Flow subscribers, Pub/Sub gRPC, etc.). | Shipped 2026-06-24 as a dormant seam. lib/salesforce-platform-event-sink.ts emits each Agent Fabric span as a custom Pause_Agent_Trace__e Platform Event via REST sObjects, authenticated via OAuth 2.0 Client Credentials against a dedicated Connected App. Best-effort, fire-and-forget — recordSpan() never waits on the sink and never throws on Salesforce errors. 22 unit tests pin env parsing, schema mapping, truncation, token caching, and the no-throw invariant on Salesforce failures. Activate by setting SF_PLATFORM_EVENT_BASE_URL + SF_PLATFORM_EVENT_CLIENT_ID + SF_PLATFORM_EVENT_CLIENT_SECRET; see docs/SF_PLATFORM_EVENT_SINK_RUNBOOK.md for the Connected App + Platform Event procurement steps. | Wired in prototype |
| Salesforce CLI parity for Pause tools | Headless 360's tagline includes 'CLI command' alongside 'API and MCP tool.' The Salesforce CLI is the operator-facing surface for everything an agent can do — Pause needed the third surface to complete the trio. | Shipped 2026-06-27 as an in-repo package: `cli/` builds to `@pause-health/cli` with `pause health`, `pause providers`, `pause timeline`, and `pause intake` commands wrapping the same `/api/mulesoft/*` surface the MCP server exposes. Hand-rolled argv parser (zero runtime deps) keeps the install lean. Supports `--json` for jq piping and `--base-url` / `PAUSE_BASE_URL` for hitting preview deploys. 17 unit tests pin the parser + client; 6 smoke cases exercise the built bin against the live Experience APIs. Not published to npm yet — gap #4 of the audit ships the artifact; the npm-scope ownership decision is a separate ops step. See `cli/README.md` for install + usage. | Wired in prototype |
The OAuth shape Headless 360 expects
Headless 360's trust model post (blog) is explicit: a non-Salesforce frontend registers as an External Client App, the user signs in via OAuth 2.0 Authorization Code + PKCE, and the client uses scopes mcp_api and refresh_token. Client Credentials / Implicit / Username-Password flows are out-of-pattern. The Pause conformance gap was that today's calls go under service-user tokens (Data Cloud) or public deployment metadata (Agentforce chat), not the user's identity through PKCE. The seam below shipped 2026-06-24 as dormant code — six routes, 25 unit tests, and HMAC-signed cookies for tamper- evident sessions. Activating it requires the External Client App procurement steps in docs/HEADLESS_360_RUNBOOK.md.
# Activation env vars (set these, then redeploy):
SF_HEADLESS360_CLIENT_ID=<External Client App Consumer Key>
SF_HEADLESS360_AUTH_BASE_URL=https://<my-org>.my.salesforce.com
SF_HEADLESS360_REDIRECT_URI=https://pause-health.ai/api/salesforce/headless-360/callback
SF_HEADLESS360_SESSION_SECRET=<openssl rand -hex 32>
# Optional override; defaults to "mcp_api refresh_token":
SF_HEADLESS360_SCOPES=mcp_api refresh_token api
# After end-to-end verification:
SF_HEADLESS360_VERIFIED=true
# Routes shipped today (all live, all 503 until env vars are set):
GET /api/salesforce/headless-360/config # always 200; reports status
GET /api/salesforce/headless-360/authorize # 302 → Salesforce w/ PKCE
GET /api/salesforce/headless-360/callback # exchanges the code, sets session
POST /api/salesforce/headless-360/token/refresh # rotates the access token
GET /api/salesforce/headless-360/me # signed-in Salesforce userinfo
POST /api/salesforce/headless-360/logout # clears session cookies
# Status state machine:
# designed — env vars unset → /config 200, others 503
# prototype — env vars set → all routes live
# shipped — VERIFIED=true → operator confirmed E2E (gap #1 closed)Honest framing
Pause is not a Salesforce product. Pause uses Salesforce surfaces — Data 360, Agentforce, Service Cloud, Anypoint / MuleSoft — under the patterns Salesforce recommends for non-Salesforce frontends. The Headless 360 umbrella is, as of June 2026, a Salesforce Architects blog family (TDX 2026 announcement), not yet a help.salesforce.com or developer.salesforce.com doc family. This page does not claim Pause is “Headless 360 certified” or “Salesforce-blessed”; it claims that the architecture maps cleanly onto the three patterns, with honest pills on every row, and the missing pieces named.
When Salesforce publishes a formal Headless 360 conformance spec (or a developer.salesforce.com doc family), this audit will be the easiest place to verify the prototype against that spec — every row is already mapped.
Read deeper
How the Data Cloud grounding query, the a360 token exchange, and the three Calculated Insights show what Pause already does in the REST pattern of Headless 360.
Pause's MCP surface (server + host) is the most complete pattern conformance today — Streamable HTTP + stdio + a host-side bridge inside the Care Router.
The chat embed uses the public deployment metadata pattern, not PKCE. Honest about that here so the Headless 360 mapping below stays accurate.
The voice channel for Headless 360. Seam shipped 2026-06-24; audio round-trip gated on Agentforce Contact Center licensing.
The A2A endpoint at /api/agents/care-router/tasks plus the per-span Agent Fabric trace surface. Headless 360's A2A leg.
The umbrella positioning post (Salesforce Architects blog, TDX 2026).
The OAuth + PKCE + External Client App story — the bit Pause's audit calls out as the next gap to close.
Which Headless 360 pattern to use when. The three-row mapping table on this page is a direct application of that guide to Pause's surfaces.