AWS Builder Center
Your Company Forgot Why. We Built a Graph That Remembers.

Your Company Forgot Why. We Built a Graph That Remembers.

Engineering teams don't just lose documentation—they lose the reasoning behind critical decisions. This article explores how we built WhyGraph / RECALL with FalkorDB to connect decision lineage, supporting evidence, system dependencies, and graph-grounded AI assistance into a more explainable engineering memory.

Your Company Forgot Why. We Built a Graph That Remembers.

Engineering teams don't just lose documentation. They lose the reasoning behind critical decisions.
When engineers leave, architectures evolve, or evidence becomes outdated, teams struggle to answer four questions: Why was this decision made? What depends on it? Which evidence is no longer valid? What could break if we change it?
We built WhyGraph / RECALL for Graph Hacks 2026 to explore a better approach: an organizational memory powered by FalkorDB, where decisions, evidence, dependencies, and agent tasks are connected and queryable.

From scattered knowledge to connected reasoning

A document search can find an architecture decision. But finding that document is only the beginning.
An engineer may also need to discover which decision superseded it, which evidence supports it, which services depend on it, and what should be reviewed before changing it.
WhyGraph represents these connections as a knowledge graph. Its Impact Lab lets users investigate change scenarios, explore dependency paths, and inspect the evidence behind the results. RECALL Copilot provides a conversational interface to graph-grounded information.
Our goal is not to build another chatbot. It is to make organizational knowledge connected, traceable, and useful during engineering decisions.

Why FalkorDB is central to the design

FalkorDB is the core graph database behind WhyGraph. The application uses graph relationships and Cypher queries to investigate questions that naturally involve multiple connected entities.
Our model connects engineering decisions, supporting documents, services, teams, dependencies, questions, playbooks, tasks, and proposed changes.
This structure makes relationships first-class data. Instead of manually collecting isolated search results, the application can traverse paths between decisions and their consequences.

1. Trace decision lineage

Decisions evolve. A newer architecture decision may supersede an older one, while both remain relevant to understanding the system's history.
WhyGraph uses Cypher traversals across relationships such as  SUPERSEDES  and  BASED_ON  to follow decision history and connect decisions to supporting evidence.
This helps engineers investigate why a design exists, what earlier decisions it replaced, and which records should be reviewed before making a change.

2. Investigate downstream impact

Changing a shared service can affect systems that are not immediately obvious.
WhyGraph uses multi-hop  DEPENDS_ON  traversals to explore downstream relationships. Its Impact Lab presents these paths visually, helping users investigate a potential blast radius.
We also use graph algorithms, including PageRank and shortest-path analysis, to support dependency investigation and identify potentially important paths.
These results are decision-support signals, not guarantees that every real-world failure has been identified. Their usefulness depends on the completeness and accuracy of the graph data.

3. Connect evidence changes to decisions

An architecture decision can outlive the evidence that originally justified it.
WhyGraph uses relationships between decisions and evidence to help identify records that may need revalidation when documents are superseded or deprecated.
This makes evidence freshness a connected-knowledge problem rather than an isolated document-management task. Engineers can investigate which related decisions and systems might require another look.

4. Make graph-grounded assistance inspectable

AI responses are useful only when people can evaluate their basis.
RECALL Copilot uses graph-backed facts and query results in its deterministic, graph-grounded mode. Node references and expandable Cypher query receipts help users inspect the information behind an explanation.
The core mode works without a paid language-model API. Optional language-model integration can be configured separately.
The distinction is important: the graph supplies the underlying evidence, while the assistant helps users navigate and understand it. A fluent answer is not treated as proof on its own.

5. Give agents persistent memory

WhyGraph also explores graph-based agent coordination.
The prototype represents episodic memory with  Question  nodes, procedural memory with  Playbook  nodes, and Analyst–Archivist coordination with persistent  Task  nodes.
These records make task state and handoffs more inspectable than coordination kept entirely inside transient prompts. Separate example graphs, including  team_lumen  and  team_orbit , demonstrate tenant isolation.

6. Keep consequential actions auditable

Understanding a proposed change is not the same as authorizing it.
WhyGraph represents proposed actions as  ChangeRequest  nodes with an explicit  DRAFT — HUMAN APPROVAL REQUIRED  boundary. This creates a record for review without silently applying consequential changes.
Our design principle is simple: use graph-based reasoning to help people make better decisions while keeping people in control of important actions.

What we tested

Our latest local verification report records 36 out of 36 FalkorDB self-checks passing, with zero reported failures or warnings, and 25 out of 25 unit tests passing.
The reported checks cover graph traversal, graph algorithms, API routes, tenant isolation, and agent handoff scenarios. These are local test results, not independent benchmarks or proof of a public cloud deployment.
One implementation limitation is worth stating clearly: this version uses a native graph tool registry and parameterized Cypher operations. An external MCP server was not implemented.

Lessons from building WhyGraph

First, relationships can be more valuable than isolated records. A decision becomes more useful when it is connected to its evidence, successors, and dependent systems.
Second, explainability needs a usable interface. Graph queries are powerful, but engineers need a way to explore paths and understand why a result matters.
Third, persistent agent memory should be inspectable. Representing tasks and decisions as graph records provides concrete state that can be reviewed.
Finally, a graph cannot recover knowledge that was never recorded. The quality of the results depends on accurate source information, meaningful relationships, and ongoing maintenance.

What comes next?

Our next steps are to validate the model against more realistic organizational data, improve evidence provenance and freshness handling, expand scenario coverage, and complete public deployment verification.
A production-ready version would also require stronger access controls, operational monitoring, backup and recovery procedures, and careful validation of tenant boundaries.

The bigger idea

An organization should be able to ask not only, “What did we decide?” but also, “Why did we decide it, what supports it, and what could happen if it changes?”
WhyGraph / RECALL explores how FalkorDB can help connect those answers through graph relationships, Cypher traversals, graph algorithms, and inspectable evidence.
We built this prototype for Graph Hacks 2026 as a step toward organizational memory that preserves not just records, but the reasoning connecting them.
Project: WhyGraph / RECALL Team: Shunya Code Repository:  https://github.com/Ajayrathod04/WhyGraph 
We would love to hear how other engineering teams preserve decision context and investigate the impact of change.
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