
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.
We would love to hear how other engineering teams preserve decision context and investigate the impact of change.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article