Enterprise Platforms Go Agent-Native: May 2026

Salesforce Headless 360, Okta's agent identity, Microsoft ADK 1.0, and Google Java ADK signal a structural shift.

Three platform announcements from the past two weeks describe the same structural shift — and most coverage is missing the pattern.

Salesforce exposed every capability as an API, MCP tool, or CLI command at TrailblazerDX 2026. Okta shipped agent-specific identity with scoped OAuth at Showcase. Microsoft made its Agent Framework production-ready at 1.0 across .NET and Python with native A2A and MCP support. Google hit ADK 1.0 for Java with Firestore-backed session memory and human-in-the-loop confirmations.

Taken individually, these are product updates. Taken together, they describe the end of the GUI-era enterprise stack. Platforms are no longer building surfaces for human operators — they’re building surfaces for agents.

Salesforce Headless 360: The Whole Platform, No Browser

Salesforce’s announcement is the most architecturally significant. Headless 360 doesn’t just add an API to Salesforce — it exposes the entire platform as headless primitives. Data, workflows, automation rules, and Agentforce capabilities are all addressable without a browser.

The MCP tool layer is the detail that matters for builders. Every Salesforce operation is now a callable tool with standardized parameter schemas and return types. Any agent framework that speaks MCP — LangGraph, the OpenAI Agents SDK, Google ADK — can invoke Salesforce operations without custom integration code. The protocol, not the SDK, becomes the integration boundary.

For teams building agents that interact with CRM data, this eliminates a class of bespoke connector development that has been a tax on every agent project since 2024.

Okta for AI Agents: Identity Is the Next Moat

Okta’s Blueprint for the Secure Agentic Enterprise addresses a gap we’ve flagged repeatedly: agents currently authenticate as their human creators or operators, which means you can’t actually audit what an agent did versus what a human did.

The new offering introduces scoped identities for agents with separate credential stores, permission boundaries, and audit trails. An agent can be issued its own OAuth client, granted a subset of the delegating user’s permissions, and have every action logged under that agent’s identity. When the agent’s scope is too broad for a particular action, Okta’s policy engine can demand human confirmation.

This is the infrastructure that makes the “agent as org member” model actually viable. Without it, every agent access pattern is indistinguishable from its creator — a compliance nightmare auditors won’t accept.

Microsoft and Google: 1.0 Signals Production Readiness

Microsoft Agent Framework 1.0 is notable for what it doesn’t do: it works with any model provider. You’re not locked into Azure OpenAI models. The framework handles multi-agent orchestration via A2A protocol natively, meaning agents built on Microsoft’s framework can hand off tasks to agents built on OpenAI’s SDK, LangGraph, or anything else that implements A2A.

Google’s ADK for Java 1.0 is the complement to the Python and Go versions they shipped earlier. The enterprise relevance is the Firestore integration — session state and memory artifacts are persisted to Google Cloud infrastructure with configurable retention, not stored in ephemeral container memory. The human-in-the-loop primitive (action confirmations that pause agent execution pending approval) is exactly the governance control our clients were asking for in Q1.

The pattern across both: 1.0 means stable APIs, breaking-change guarantees, and long-term support. Enterprise procurement departments care about this. It’s the difference between “evaluating” and “deploying.”

What This Means for Agent Architecture

Three concrete implications for teams building agents right now:

1. MCP is the new REST. Platforms are choosing MCP as the standard tool-description protocol. If your agent framework doesn’t support MCP natively, you’ll be writing custom adapters for every enterprise integration. We’ve already started treating MCP support as a framework selection criterion, alongside state management and observability.

2. Agent identity is solvable. Okta’s scoped agent credentials remove the shared-authentication problem that has been a blocker for regulated industries. Teams in fintech and healthcare can now model agents as distinct identities with their own permission boundaries and audit trails.

3. Protocol interoperability is arriving. A2A support in both Microsoft’s framework and the broader ecosystem means agents will increasingly be composable across platform boundaries rather than siloed within one vendor’s stack. The protocol layer we mapped last month is moving from theory to implementation.

The headline isn’t any single announcement. It’s that the four largest enterprise platform vendors are all building the same thing: surfaces for agents, not humans. The infrastructure to support that — identity, protocol, memory, and access control — is arriving in the same quarter. The gap between “demo agent” and “production agent” just got narrower.