← Sonal Goyal's posts

The Context Layer Is Customer 360 With a New Name

View Original ↗

Picture an agent pulling “full customer context” before it handles a support escalation. The customer is unhappy, the agent has access to the CRM, the billing system and the support history, and its job is to decide whether to offer a goodwill credit.

It finds three records for the same lady. In the CRM, she’s a VIP with years of purchase history. In the billing system, under a slightly different email, she’s flagged as a churn risk after two failed payments. In the risk system, under her maiden name and an old address, there’s an open fraud review.

The agent picks one and acts on it, confidently. Nothing in its context tells it that these three records are the same person.

Most post-mortems would file this under context failure: the agent didn’t have the right information. But it did. It had more information than a human support rep would ever pull up. What it lacked was the answer to a far more basic question: who is this?

Every piece of context an agent uses hangs off an entity. A policy applies to a customer. A transaction belongs to an account. A claim belongs to a patient. Get the entity wrong and everything attached to it is wrong too, in a way that looks perfectly coherent to the model reading it.

Context without identity is just a bigger prompt.

It’s worth being precise about which context I mean, because the word is doing a lot of work right now. There are many kinds. When you’re coding with an agent, context is the repository, the open files and the conventions of the codebase. When you’re drafting with one, it’s the documents you hand it.

The context layer I’m talking about is different. It’s context about the business itself: its customers, suppliers, products, accounts and patients, and how they relate to one another.

I’ve been listening closely to how teams describe the context layer they’re building for their agents. The words vary - semantic layer, knowledge graph, master data management, but the brief is remarkably consistent: a unified, current, trustworthy view of the entities the business cares about, joined across every system, governed, and available on demand to whatever needs it.

We’ve heard that brief before. A decade ago we called it Customer 360.

The vocabulary has moved on. We say retrieval and embeddings instead of golden records and data hubs, and the consumer is an agent rather than a dashboard. Strip away the new words, though, and the architecture diagram looks familiar: sources on the left, a unified view in the middle, consumers on the right. The context layer is Customer 360 with a new name.

That isn’t a criticism. Customer 360 was the right idea. The question worth asking is why so many of those programs never delivered it.

Most Customer 360 programs I’ve seen didn’t stall because of the dashboards, the warehouse, or the models on top. They stalled at the least glamorous line on the project plan: deciding which records refer to the same customer.

Matching was treated as a migration task. A team ran a cleanup, produced a golden record, and moved on to the visible work. Then the business kept moving. Customers changed emails, moved house, got married, opened a second account for a side business. New systems came online with their own identifiers. The golden record started decaying the day it went live, and nobody owned the job of keeping it true.

The pattern shows up in every industry I work with. In retail, the loyalty member and the guest-checkout buyer are the same household, but the promotions engine treats them as strangers. In financial services, an individual and their sole proprietorship share an address, a phone number and a risk profile, yet sit in different systems with different owners. In healthcare, a patient registered at two facilities becomes two patients, each with half a history.

None of these are exotic edge cases. They’re the normal state of enterprise data, and they come back the moment you stop resolving.

A stale Customer 360 had a cost, but a forgiving one. A wrong record produced a wrong number in a quarterly review, and someone in the room usually said “that doesn’t look right.” Humans were the error-correction layer.

Agents remove that layer. They don’t just read the context, they act on it: approve the refund, route the claim, release the payment, send the offer. And they act at a volume where nobody is looking at each decision.

That changes how entity errors behave. A duplicate customer in a dashboard is a reporting inaccuracy. A duplicate customer in an agent’s context is a wrong action, repeated every time that record is retrieved. Worse, the mistakes look reasonable. The agent’s reasoning will be fluent and internally consistent, because it is reasoning correctly about the wrong entity.

When agents query, identity errors are noise. When agents act, they become decisions.

If the context layer is going to avoid the fate of Customer 360, identity can’t be a preprocessing step someone runs once before the interesting work begins. It has to be treated as infrastructure, with a few properties that rarely show up in the context layer designs I’ve seen.

Resolution has to be continuous. New records arrive, existing ones change, and the answer to “who is this?” has to stay current as the data moves, not get rebuilt in an annual cleanup.

Decisions have to be explainable. When an agent acts on a merged entity, someone will eventually ask why those records were treated as one. If you can’t show which records were matched, on what evidence, and when, you can’t audit the action that followed.

Humans have to stay in the loop where it counts. Most matches are easy. The ambiguous ones are where the risk sits, and they need a path to be reviewed, corrected, and fed back so the same mistake doesn’t repeat.

Someone has to own it. In most organizations I talk to, the retrieval layer has an owner, the model has an owner, and the agent has an owner. The question of whether two records are the same customer usually belongs to nobody.

Retrieval is the easy part of the context layer. The identity underneath is the actual product.

If your team is building a context layer right now, I’d love to hear how you’re handling identity. Is entity resolution part of the design, or is it assumed to be solved somewhere upstream? And when an agent acts on the wrong customer, who in your organization gets the call?

Tell me in the comments.