AWS Builder Center
Agents forget. Graphs remember. Knowledge graphs behind agentic customer experience

Agents forget. Graphs remember. Knowledge graphs behind agentic customer experience

Customer-facing agents fail on questions whose answer is a chain across systems, and they forget the customer between sessions. A knowledge graph fixes both. What that looks like in travel and hospitality, and how to build it on AWS with GraphRAG, Neptune, AgentCore Memory, the open-source Context Ontology Accelerator, and the announced AWS Context.

A loyalty member opens the rental app on Tuesday night and asks the assistant a simple question: "There's a recall in the news for the model I booked. Is my car on Thursday affected, and if it is, what happens to my reservation?"
The assistant has read the recall notice. It has read the loyalty program terms. It has read the branch's fleet policy. It answers with a paragraph about recalls in general, a paragraph about the customer's elite status, and an invitation to call the branch. Every sentence is accurate. None of them answers the question, because the answer lives in no single document. It lives in the chain between them: this reservation is assigned to this vehicle class at this branch, the branch holds these units, four of them carry a VIN inside the recall range, and the loyalty tier entitles the member to a free upgrade when a vehicle is withdrawn. Five facts, four systems, one walk.
This is the failure mode of most customer-facing agents today, and it is not a model problem. The model is fine. The agent cannot follow a chain of facts across systems, and it cannot remember what it learned the last time this customer called. A knowledge graph fixes both. This post is about why, what it looks like in travel and hospitality, and how to build it on AWS with what is available today, what is open source, and what AWS announced is coming.

The short version

  • Customer questions that matter contain the word "across": across reservations and vehicles, across flights and crew, across a loyalty account and a case history. Retrieval over documents finds things that sound alike. It cannot follow a chain.
  • A knowledge graph stores how facts connect, as data. The agent walks the chain instead of a developer writing a join for each question. The answer comes back with the path it took, which is what makes it auditable.
  • Memory is the second half. An agent that stores entities and relationships across sessions improves with use. An agent that stores chat logs does not.
  • On AWS the pieces exist today: Amazon Bedrock Knowledge Bases with GraphRAG, Amazon Neptune, Amazon Bedrock AgentCore Memory, business context in the AWS Glue Data Catalog, and the open-source Context Ontology Accelerator for ontologies and rules. AWS Context, announced at the AWS Summit New York in June 2026, is the managed version of the whole idea.
  • Start now. The entities you name, the relationships you map, and the owner you assign carry over to whatever runs the graph next.

How customers solve this today

Three ways, all real.
A person who knows both systems. A senior agent at the branch, an analyst in revenue management, the one engineer who remembers why the reservation table has two customer ID columns. They answer the cross-system question from memory, slowly, and when they leave the answer leaves with them.
An integration per question. A pipeline, a join, or a dashboard built to answer one question well. It takes months, it is rigid once built, and the next question starts another project. Most enterprise data estates are the sediment of this approach.
A chatbot on document search. The current default. Chunk the documents, embed them, retrieve the chunks that look like the question, hand them to a model. This works for questions whose answer sits in one place. It fails on the question above, and on every question like it, because similarity is not connection. The recall notice and the loyalty terms do not resemble each other; they are joined by a reservation neither of them mentions.
The graph does not replace these systems. It replaces the project between them.

What a knowledge graph is, in plain words

A table knows what things are: vehicle 4711 is a compact, located in Atlanta, acquired in March. A graph knows how things relate: customer C-88 rented vehicle 4711 from the Atlanta airport branch under reservation R-2043; vehicle 4711 is made of parts covered by recall N-17; recall N-17 affects the Atlanta branch's Thursday availability.
Two properties matter for agents.
First, the connections are stored as data, not as code. "Which branches hold vehicles from this recall?" is one walk in a graph: recall, to vehicle, to branch. In a relational store it is a six-way join somebody has to write first. In a document store it is unanswerable.
Second, the graph points at the data; it does not hold it. The node for reservation R-2043 carries an identifier and a few attributes and points at the record in the reservation system. The data platform underneath stays where it is, with its permissions. This is what makes a graph practical to add to an estate that already exists: it is an index of meaning over systems of record, not another copy of them.
If a customer's question has "across" in it, it is a graph question. If it has "why" in it, it is a graph question with an audit requirement.

What the customer experience gains

Answers that cross systems. The recall question gets answered: "Two of the four compacts at Atlanta airport are in the recall range. Your reservation is protected; if a compact is withdrawn you move to a midsize at no charge under your tier." That is a different product from a paragraph about recalls.
Answers that can be audited. The agent shows the chain: reservation, vehicle class, branch inventory, recall range, loyalty rule. A supervisor can check it. A regulator can check it. An airline running an agent that proposes crew reassignments during irregular operations cannot ship it without the "why did you propose this?" button, and the button is a graph walk shown to a human.
Agents that remember. The customer who called about the recall on Tuesday should not re-explain it on Thursday. Memory that stores entities and relationships, not transcripts, is what lets the agent say "you asked about the recall; here is the status of your assigned vehicle" and mean it.
Developers who ship faster. The agents behind these experiences are software. The teams building them need to know what breaks when they change a shared module, which services expose the reservation record, and which utility is the approved one. That is also a graph, over a different corpus. More on that below.
These four compound. Grounding raises answer quality. Quality raises trust. Trust raises usage. In a contact center, usage is containment and handle time; in an app, it is the share of interactions that end without a human.

Two graphs, kept apart on purpose

Customers who get serious about this end up with two graphs and resist merging them. That is correct, and it is worth understanding why before you propose a single "enterprise knowledge graph."
The business knowledge graph is built from documents, catalogs, databases, and an ontology that names what the business calls things and how they relate: customer, reservation, vehicle, branch, recall, fare rule, crew pairing. It is owned by data and AI leadership. It is consumed by customer-facing agents and analysts. It buys cross-system answers and auditability.
The code knowledge graph is built from repositories: symbols, the call graph, service boundaries, and the business meaning inferred from entry points and tests. It is owned by engineering and platform teams. It is consumed by coding agents and developers through tools like Kiro and MCP servers. It buys developer productivity, safe change, and fewer wasted tokens re-discovering the same codebase.
They stay apart for four reasons. The owners and budgets differ. The sources differ: code is deterministic and parses; business meaning has to be modelled. The stores differ: a code graph is typically vectors plus symbols; a business graph is a property graph or RDF with an ontology. And the security boundary differs: source code and customer data rarely share a store, and nobody wants to be the one who made them.
Sequence them rather than merge them. Code first if your bottleneck is shipping agents; business first if your bottleneck is agents that answer badly. The customer-experience agent sits where they meet: it reads customer data through services the code graph describes, and it reasons over relationships the business graph holds.

The ontology is where the rules live

A graph of entities and relationships answers "what is connected to what." Customer experience also needs "what is allowed." The loyalty upgrade rule, the recall withdrawal policy, the crew legality constraint are business rules, and an agent that can traverse the graph but not validate against the rules will propose things it should not.
This is what an ontology adds: a formal vocabulary for the domain, plus rules the agent's conclusions must satisfy. The Context Ontology Accelerator is an open-source project from AWS (Apache 2.0) that builds exactly this layer: it helps a team define its ontology, infers a knowledge graph from documents and databases with steward review before changes are applied, and exposes it to agents through REST and an MCP server. Natural-language questions can be answered by generating SQL directly or by expressing the question as a graph query over the ontology and rewriting it to SQL, with the strategy selectable per request. The point is not the query engine; it is that the agent's answer is checked against a model of the business before it reaches the customer.
GroundWork, an open-source sample built on the accelerator, shows the pattern applied to security and operations: point it at messy sources and it builds a governed graph you can query, with "what is downstream if this fails?" as the hero question. Swap the domain and the question becomes "which reservations are exposed if this branch loses six vehicles?"

Where this is going: AWS Context

At the AWS Summit New York in June 2026, AWS announced AWS Context, a managed service that automatically maps the relationships across an organization's existing data into a knowledge graph and provides agentic search, so agents can access governed data relationships, business rules, and domain knowledge at runtime. Data stewards review inferred relationships, promote them to production, and attach business definitions and usage rules. It integrates with the AWS Glue Data Catalog, Amazon SageMaker Unified Studio, and AWS Lake Formation, and publishes key elements of the context layer to Amazon S3 in Apache Iceberg format so other tools can use it. It extends the knowledge graph technology that already runs under Amazon Quick for hundreds of thousands of daily users.
The announcement describes it as coming soon. The relevant point for a team building customer-experience agents now is what carries over: the entities you have named, the relationships you have mapped, the rules you have written down, and the owner you have assigned. A team that has done that work on Bedrock Knowledge Bases GraphRAG, on Neptune, or on the Context Ontology Accelerator is a team that is ready for a managed organizational graph the day it is available. A team that has not is starting from the three ways customers solve this today.

Building it on AWS today


Figure: the context layer sits between the agent and the systems of record. Where the graph points, the data stays.
Agents. Amazon Bedrock AgentCore provides the runtime, identity, and gateway for the agent itself, and AgentCore Memory provides short-term session memory plus long-term memory that extracts facts and preferences across sessions. This is the "agents that remember" half, and it is a configuration decision, not a build.
Knowledge from documents. Amazon Bedrock Knowledge Bases with GraphRAG ingests the documents, builds a graph of entities and relationships automatically using Amazon Neptune Analytics under the hood, and returns answers that traverse the graph and cite their sources. For the recall notice, the loyalty terms, and the fleet policy, this is the fastest path from documents to cross-document answers.
Knowledge from systems. Amazon Neptune holds the operational graph: customer, reservation, vehicle, branch, recall, case. Neptune Analytics runs the questions that need algorithms rather than lookups: impact analysis, community detection, "if this fails, what is downstream." Entity resolution across operational systems (the same vehicle under three identifiers) lives here; identity resolution for the contact center is a different job and belongs to Amazon Connect Customer Profiles. The two coexist: Customer Profiles resolves the person, the graph connects the person to vehicles, contracts, and incidents.
Business meaning and rules. Business descriptions on tables and columns in the AWS Glue Data Catalog give agents the vocabulary of the lakehouse. The Context Ontology Accelerator adds the ontology and the rules, with an MCP server the agent calls.
Data. Amazon S3, Amazon Redshift, the Glue catalog, the lakehouse: the systems of record do not move. The graph points at them.
The sequence that works: pick one cross-system question customers actually ask, name the five entities in it, map the relationships, put a human owner on the graph, and ship the agent against that. Then add the second question. The teams that fail here try to model the enterprise first.

Six sentences that tell you it is a graph problem

If you run a customer-experience, data, or platform team, these are the sentences that mean you have a graph problem and not a model problem.
You hear
It means
Start with
"Our chatbot fails on questions that span documents or systems."
Similarity search cannot follow a chain
Bedrock Knowledge Bases GraphRAG
"The same vehicle, contract, or supplier shows up under three IDs."
Entity resolution across operational systems
Neptune; Customer Profiles for the person
"Our agents forget everything between sessions."
Memory stored as transcripts, not entities
AgentCore Memory
"Nobody knows what breaks when we touch this module."
No graph over the code
A code knowledge graph for coding agents
"Our data sits in 12 systems and every agent answers differently."
No shared context layer
Glue Data Catalog business context now; AWS Context when available
"If X fails, what is downstream?"
Impact analysis over a network
Neptune Analytics
Two words give it away: "across" and "why." Hear either one from a customer, a supervisor, or a regulator, and the answer is a graph.

What to do Monday

Write down the single cross-system question your customers ask most and your agent answers worst. Name the entities in it. Draw the relationships on one page. Decide who owns that page. Then build the smallest graph that answers that one question, and show the path to the people who have to trust it.
Agents forget. Graphs remember. The customer notices the difference.



References

  1. AWS, "Context intelligence for your data and AI agents at scale," AWS Machine Learning Blog, 17 June 2026.  https://aws.amazon.com/blogs/machine-learning/context-intelligence-for-your-data-and-ai-agents-at-scale/ 
  1. AWS, "Amazon Web Services now introduces Context Ontology Accelerator," What's New, July 2026.  https://aws.amazon.com/about-aws/whats-new/2026/07/aws-context--ontology-accelarator-generally-available/ 
  1. Context Ontology Accelerator, open-source repository and documentation.  https://github.com/aws/context-ontology-accelerator  and  https://aws.github.io/context-ontology-accelerator/ 
  1. GroundWork, open-source sample built on the Context Ontology Accelerator.  https://github.com/aws-samples/sample-groundwork 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article