An account executive opens a $5M expansion that the CRM marks “Commit” and asks an agent for the next best action. Working from the CRM alone, the agent does the sensible thing: it drafts an email to close the deal. It is confident and wrong.
The enterprise already knows far more than the CRM is telling it. Product usage has fallen 27%. Billing shows an open dispute, and a master agreement carries an unsigned compliance rider. Recently, after an outage, a customer success agent proposed, and a human confirmed, holding renewal pricing flat and waiving the overages (“Outage goodwill”).
Give the sales agent a shared, assembled, governed context and the answer changes completely. The agent surfaces the outage, the unsigned rider, and the billing dispute, and inherits only the memories it is cleared for, so legal’s privileged review of that rider stays away from the seller, who is not entitled to see it. It recommends reaching out to the exec sponsor with a service update that honors the confirmed price hold and overage waiver rather than firing off an automated close. Same question, completely different answer and action. The data existed across systems; what was missing was a way to govern and assemble it for the moment of decision.
The gap is not data. It is context.
Every company has more data than it has ever had: about its business, its customers, its products, its supply chain. Turning that data into advantage is the hard part, and it has never mattered more than it does in a world of AI.
Companies want their data to drive better conversations, trigger the right actions, power predictions, and let agents complete real work with the right oversight.
That ambition tracks a deeper shift. For thirty years, software has stored your data and routed your work. Now it is starting to do the work.
Every one of those ambitions depends on context: the right slice of what the company knows, assembled for the exact situation at hand, so a person or an agent can act to create the right outcome.
Every company already owns identity systems, business processes, data platforms, governance, and knowledge bases in some form, yet still has no usable context. The pieces are fragmented and never assembled. Identity is split across channels. Transactions live in one system and conversations in another. Processes are captured in outdated maps rather than anything an agent can act on. Behavioral signals exist but are not retrievable at the moment of decision. Memory, where it exists at all, belongs to a single agent rather than every agent and person in the company.
The result is agents that answer from a static body of knowledge, where the answer is not shaped by who this customer is, what they are doing, what is happening now, what the data means, or what each agent is allowed to see. A marketing agent retargets a customer who churned yesterday or already converted on another channel. A customer moving across channels and agents gets treated as a stranger each time.
Introducing the Agent Context Engine
At Dreamforce we announced the Agent Context Engine (ACE) specifically to close this gap.
ACE is a shared context layer that works across your agents and across platforms. Any agent on a supported platform can get context from it, whether it was built on Agentforce, Google ADK, AWS Bedrock, LangGraph, or the OpenAI SDK. Agents built outside Agentforce can use the SDK code or MCP tools to retrieve the same governed context as every other agent, based on their permitted scope. Your agents start behaving like a team: they remember, they understand, and they hand off learnings to each other and to people, so customers and employees never have to repeat themselves.
The context every agent draws on is shared, governed, and continuously maintained. It is created and updated as the enterprise operates, and it compounds. So each decision is better informed than the last, and each new agent is faster to stand up and more trusted.
ACE is a new layer on a proven foundation, not a stack built from scratch. It inherits what already makes Data 360 the #1 Customer Data Platform: the real-time pipeline, zero-copy access to data where it lives, identity resolution, tagging, and governance. ACE adds the knowledge-graph and traversal engine that assembles context (GraphRAG). Data 360 customers extend their existing investment; everyone else gets rapid time to value, with no Customer Data Platform implementation required.
Without the Agent Context Engine
Consider what ACE replaces. Today each agent is built with its own private context, most commonly configured with a search index plus a few queries against structured data. That is why most custom-built agents end up siloed, generic, cold to each customer, and unable to learn. Worst of all, they are commonly blind to live events like a canceled flight or an outage.
Agent platforms have started to provide memory and learning, but they stop at the platform boundary. When a customer moves between agents, channels, and people, the next interaction loses what the enterprise already knows. When each team rebuilds its own context, agents end up on different sources and different governance, and they interpret the same business terms differently. That duplication is expensive to build and maintain, and the deeper cost is a loss of consistency in governance and experience.
With the Agent Context Engine
The Agent Context Engine translates an incoming prompt into the minimum data needed for the maximum result.
How ACE assembles a request
To make this work, business experts define the relevant sources, business terms, and intended use for a job, and ACE reuses that definition on every request across every agent. A shared metadata and semantic layer, built on the Tableau Semantic Data Models that are now part of Data 360, explains what the data means, so every agent interprets “active customer” or “account health” the same way.
What ACE hands the agent is a scoped payload assembled for that one request: the resolved customer profile, the relevant memories, the real-time signals about what the customer is doing right now, and the slice of the knowledge graph relevant to the scenario. Every element is filtered to what this agent is permitted to see.
With that information and instructions in hand, ACE builds that payload by following the connections in the graph, starting from the resolved customer and traversing only to the facts that are relevant and permitted, within the business context you defined, rather than scanning everything. The result is higher accuracy and lower cost than iterative reasoning that scans the data repeatedly. It also assembles context fast enough to keep the interaction responsive.
Learn more about How Data 360 builds trusted context.
How context compounds over time
ACE turns the exhaust each agent produces as it works (the raw conversation and the agent’s reasoning steps) into shared memory. It mines that exhaust for facts, preferences, and learnings, and persists them with provenance and governance so the next agent can build on them. The customer success agent’s recorded price hold from the opening is exactly that: one agent’s exhaust, governed and persisted, that the sales agent later reads and honors. And the value extends beyond creating continuity across agents. Over time, signals from agent interactions let the enterprise learn in aggregate and improve business processes such as service workflows, along with CRM experiences and derived insights.
Agents raise two governance questions a security team cares about: what an agent can read, and what it can write. ACE uses the capabilities in Data 360 to govern both.
How context is governed
At the moment context is assembled, context assembly applies the entitlements you already enforce in Salesforce and Data 360 (object, field, and row-level security, sharing rules, data classification). What is safe to surface is set by your data-classification policy, not inferred by the model. Sensitive content is masked or withheld before it reaches the agent. That is how the seller in the opening knew a legal issue was open without reading the privileged discussion.
For data that stays in your warehouse through zero-copy, Data 360 governance layers on top of the controls you already run in Snowflake, Databricks, or BigQuery; it does not replace them.
What agents write is governed too. Agents now create memory, and an unchecked memory means one agent’s guess becomes another agent’s “fact.” In ACE, every memory is traceable to its source, inherits that source’s protections, and can require human confirmation before other agents rely on it. Changes to your systems of record still go through each system’s own permissions. The same Data 360 policies apply to agents as they do to humans using Data 360 directly.
Why this matters now
It is the difference between agents that help the business and agents that erode trust.
Four reasons.
- Agents are rapidly expanding into revenue and customer-facing work where a confident, well-worded mistake now costs real accounts, like the “Commit and close” email on an account that is quietly on fire.
- The number of agents per enterprise is climbing fast, and standing up private context for each one is becoming too expensive to build and too fragmented to govern.
- Inference cost scales with the context fed into each request, so holding every request to the minimum necessary payload is what decides whether agents deliver ROI at scale.
- Customers and employees now expect an accurate, relevant, personal experience when working and conversing across agents, and that requires shared context.
The bottom line
Go back to the $5M deal. The difference between the closing email and saving the customer was never about the LLM. It was context: assembled, current, and governed, delivered to the agent exactly when it mattered. That is the shift ACE makes, and it changes what an agent can do across every account, every channel, and every team you run.
For any leader betting on agents, this is the layer that decides whether those agents are impressive demos or dependable members of the team. ACE is in preview now, and you can start using it today. Go here to get started with agent registration and configuration.
