AWS Builder Center
The Bug Wasn’t What Made Them Escalate. The Broken Promise Was.

The Bug Wasn’t What Made Them Escalate. The Broken Promise Was.

A synthetic customer escalation shows why teams need to remember more than the latest ticket: promises, owners, follow-ups, and SLA terms all shape what should happen next. Follow how FalkorDB and LangGraph power the prototype—and what a real deployment could measure.

How a customer-support incident became a graph-powered memory problem—and how PromiseGraph tries to close the loop.
At 12:30 p.m., the escalation timeline records a first-response breach.
By then, Bluepeak Robotics has already reported the same CSV export problem three times. The export is still dropping custom fields. A fix was promised for October 14. An engineering status was promised for noon on October 15. Both deadlines have passed. The bug is still open. No confirmed fix date is recorded.
In one system, there is a ticket. In another, a call note. Somewhere else, an engineering issue and a contract clause. Each record tells part of the story. None, by itself, explains why the customer is now escalating.
The harder question isn’t “What is the bug?”
It’s “What did we promise, what happened next, and what can we safely say now?”
That question is where PromiseGraph began.
The Bluepeak Robotics account and all records in this article are synthetic demo data. The events and dates below describe the project’s sample scenario, not a real customer incident.

The moment the problem changed shape

The first instinct in a support escalation is usually to look for the technical cause. Find the bug. Find the owner. Find the status.
But a customer doesn’t experience a bug report as a neat row in an engineering tracker. They experience the sequence around it: the report, the reassurance, the deadline, the silence, and then the repeated explanation they have to give when they come back.
In the synthetic Bluepeak case, ticket  TKT-201  reports missing custom fields. The issue returns in  TKT-228 . During a call recorded as  CALL-18 , account manager Kavya Iyer commits to delivering a fix by October 14. The underlying issue is tracked as  BUG-77 . Then another support ticket,  TKT-251 , arrives with the escalation plainly stated: the promised fix was missed and the customer received no update.
A second commitment appears in the history: engineering will provide a confirmed status by noon on October 15. That follow-up is open too. The record shows that  BUG-77  remains open and names Riya Kulkarni as its engineering owner. It does not contain a confirmed new delivery date.
There is also an SLA event. The contract says a critical issue should receive an initial response within one hour; the event records a first-response breach. The same contract explicitly does not guarantee a bug-fix delivery date.
Those details change the response. A team that sees only the bug may be tempted to send another optimistic ETA. A team that sees the connected history can recognize the real risk: the customer is waiting for a reliable update after two missed commitments, while the engineering status remains uncertain.

The idea: give the escalation a memory

The project took shape around a simple question: What if an escalation could remember the commitments made across the whole customer history—not just the latest ticket?
That meant the core unit of the problem couldn’t be a chat transcript or a single support case. It had to be the connections among the records.
A ticket relates to a bug. A bug has an owner. A promise is made to a customer by a person, recorded in a call note, and may depend on that bug. A follow-up is supposed to close the loop. An SLA event is governed by a contract. Those relationships are the context.
PromiseGraph models them as a property graph in FalkorDB. The demonstration graph includes customers, cases, tickets, promises, follow-ups, bugs, people, SLA events, source documents, features, and products. Relationships such as  RELATED_TO ,  OWNED_BY ,  MADE_TO ,  MADE_BY ,  RECORDED_IN ,  DEPENDS_ON ,  CLOSES_LOOP , and  DEFINED_BY  let the application follow a question through the evidence.
In the FalkorDB Browser, one traversal makes the central path visible:
MATCH path = (c:Customer {id: 'CUST-BLUEPEAK'})
-[:HAS_CASE]->(t:Ticket)
-[:RELATED_TO]->(b:Bug)
-[:OWNED_BY]->(owner:Person)
RETURN path
The result is more than a collection of nodes. It is a compact explanation: this customer has multiple related tickets, those tickets point to the same bug, and the bug has a recorded owner.

Why a graph—and why not just ask an LLM?

A language model can write a fluent paragraph about an escalation. Fluency, however, is not the same as memory, and it is not proof that a deadline or owner is correct.
PromiseGraph uses FalkorDB to keep the evidence connected, then uses explicit Cypher patterns to retrieve the relevant paths. A ticket-to-bug-to-owner query can reveal that reports thought to be separate are connected to one issue. A promise query can follow the commitment to its customer, maker, source, dependency, and follow-up. An SLA query can link the event to the case and governing contract document.
The queries are fixed and parameterized in the backend. The browser and the model do not get to submit arbitrary Cypher. That keeps the graph’s job clear: preserve relationships and return the records the application is designed to inspect.
Then LangGraph coordinates the investigation. Its LangChain tools are intentionally narrow and read-only: one retrieves the customer’s connected context; the other retrieves the deterministic commitment analysis. The agent is instructed to use both, distinguish known facts from uncertainty, cite factual claims with record IDs, and avoid inventing an owner, a date, or a promise.
The interface streams progress as the tools start and finish. That small detail matters. Instead of a spinner that says “thinking,” an operator can see that the system is reading customer history and checking overdue commitments. The final answer arrives with citations that can be opened in a source inspector.
The model helps interpret the evidence. It does not calculate the commitment score or decide what the graph contains.

Making the promise visible

The Promise Ledger classifies commitments based on their due dates and recorded status. Overdue commitments receive a transparent triage score using case priority, time overdue, repetition, and confidence:
score = impact × overdue-days weight × repetition weight × confidence weight
The score is ordinary deterministic Python—not an LLM judgment and not a calibrated prediction of churn. Each factor is shown so an operator can understand why one promise ranks above another. The point is not to turn trust into a magic number. It is to make unresolved obligations harder to overlook.
A chronological timeline brings tickets, promise deadlines, and SLA events into one view. Clicking a source ID opens its record and the permitted graph relationships around it. That moves the user from “the agent says so” to “I can inspect where this came from.”
When it’s time to respond, the app can prepare an editable customer update with internal evidence kept separate. It does not send the message. It flags risks such as dates or internal record IDs in customer-facing text. A person remains responsible for checking the current engineering status and deciding what to communicate.

What worked in the prototype

The strongest design choice was to make the evidence path visible at every stage. FalkorDB holds the relationship structure. Cypher retrieves defined, inspectable paths. The deterministic ledger exposes its scoring factors. LangGraph coordinates tools rather than replacing them. Citations lead back to source records.
That separation makes the demo easier to reason about: data relationships live in the graph; deadline arithmetic lives in deterministic code; language generation happens only after the evidence tools return. The local test suite also exercises the seed loader, scoring, draft checks, source access, and a LangGraph tool cycle against a mock model server—without calling the live provider.
The result is a working local prototype, not a production customer-support platform. Its Bluepeak data is synthetic, its current API is single-customer, it has no production authentication or tenant authorization, and its model integration depends on a configured OpenAI-compatible tool-calling endpoint. Citation checks confirm that cited IDs were returned by the tools; they do not independently prove every sentence. The score is a triage heuristic, not a business-outcome model.
Being clear about those boundaries is part of the design. A safe system should be explicit about what it knows, what it cannot verify, and what it will not do automatically.

What could this make possible?

PromiseGraph has not yet demonstrated measured reductions in response time, churn, or escalations. Those outcomes would need to be evaluated in a real deployment with appropriate safeguards and reliable source integrations.
But the prototype points toward useful possibilities. If connected to a support organization’s authorized systems, a commitment-aware graph could help teams:
  • Find repeated issues and missed promises without manually searching several tools.
  • Surface overdue customer commitments and incomplete follow-ups earlier.
  • Route a case to the recorded engineering or account owner with its evidence attached.
  • Distinguish a contractual response obligation from an unconfirmed engineering delivery date.
  • Give a new responder a compact, source-linked history before they contact the customer.
  • Measure operational indicators—such as time to assemble case context, time from missed deadline to follow-up, and the share of updates with traceable evidence—before claiming that outcomes improved.
The practical goal is not to automate empathy. It is to make it easier for a human to keep a promise, or to be honest when the team cannot yet confirm one.

The loop is the product

A bug can remain open while an engineer investigates. A delivery date can remain unknown. Those are hard truths, but they are not necessarily the moment trust breaks.
Trust erodes when a commitment disappears into a call note, when a follow-up has no owner, or when the customer has to report the same issue again just to get an update.
PromiseGraph is an attempt to make that chain visible: what was reported, what was promised, what the evidence says now, and what a human should verify next.
The graph remembers the relationships. The agent helps navigate them. The operator closes the loop.


Project: PromiseGraph Built with: FalkorDB, FastAPI, LangChain, LangGraph, React, and TypeScript Demo data: Synthetic Bluepeak Robotics escalation records Safety boundary: Read-only investigation; customer drafts remain editable and unsent
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