THE PROBLEM
The answer is somewhere.
That’s the problem.
A launch is approaching. A payment service has a problem. Someone asks a simple question: “What does this put at risk—and who can help?”
The answer rarely lives in one document. It lives between a service, its owner, the project that depends on it, and a decision made a week ago. Finding each piece is only half the work. Someone still has to connect them.
Relay was built around that gap. It is a company brain for employees, project managers, operations teams, and Finance teams: a place to find evidence, understand relationships, and turn that context into carefully approved work.
A useful company brain should remember how things connect—and carry those connections into the next task.
The demo takes place inside Meridian, a fictional company preparing its Atlas launch. That gives the project a concrete world to work with: people, services, decisions, documents, and a Finance review that needs a real approval boundary.
THE CONNECTED CORE
The graph is where
the reasoning gets its footing.
FalkorDB stores the relationships Relay depends on. A project can depend on a service. A service can have an owner. A finding can cite a particular document version. Those connections are available to queries, not just drawn on the screen.
Ripple makes this visible. Starting with the payment gateway, a Cypher query follows dependency paths to find the work exposed to an outage. A second query looks for documented backup routes. Try the small illustration below.
One change. A ripple of consequences.
dependents
Checkout, Atlas launch, and Billing reconciliation depend on the disrupted payment gateway.
A local illustration of the sample graph, not a live query or failover. The backup assumption changes the simulated path; it does not change company facts.
With the documented backup assumption, Checkout and Atlas are no longer exposed through that route. Billing reconciliation still is. The count changes from three to one. That is a dependency count—not a prediction of outage probability.
See the Cypher behind the dependency walk
MATCH p=(dependent:Entity)-[:DEPENDS_ON*1..]->
(origin:Entity {id:$origin})
WHERE dependent.id <> $origin
AND all(edge IN relationships(p)
WHERE NOT (edge.id IN $excluded))
RETURN [node IN nodes(p) | node.id],
[edge IN relationships(p) | edge.source_ids]
ORDER BY dependent.id
$origin is payment-gateway. The
baseline $excluded list is empty.
FROM KNOWING TO DOING
Put the human yes
where it actually matters.
Finding an answer is useful. An invoice review asks a harder question: can the system use the right evidence, respect who may approve it, and leave a record of what happened?
In Relay, company research can continue while the Finance branch waits. A separate auditor reviews the exact document versions, permitted tools, and intended audience. That approval is scoped to the work, rather than granting the agent permanent access to everything.
One request. Two paths.
Company context moves. Finance waits for permission.
After approval, tools compare invoice and purchase-order rows, create HTML and CSV reports, and update an internal exception case. Optional report and case approval gates give the requester another review point. The workflow does not send payments or messages to external systems.
LangGraph coordinates the stages. FalkorDB holds the workflow relationships and checks the prerequisites, current plan, approved source versions, and permissions before work can be claimed or its results published.
MEMORY THAT SURVIVES A CORRECTION
The document changed.
The history shouldn’t disappear.
A corrected invoice should not erase the first review. It should explain why the next review is different.
Relay keeps earlier evidence versions and marks affected downstream work stale. Changed Finance evidence needs fresh approval; unchanged completed work can be reused. When the discrepancy is resolved, the existing internal case gains a new revision instead of becoming a disconnected second case.
This is also why memory needs evidence. Company investigations retain source references, so a user can return to a finding and inspect what supported it. A remembered answer is more useful when its context survives with it.
NOTES FROM THE BUILD
Three lessons worth keeping.
Make connections do real work.
A graph earns its place when relationships change a result or determine whether work can proceed. In Relay, the same graph supports dependency analysis, evidence tracing, and execution checks. Without FalkorDB, those core workflows cannot function.
An approval belongs to a version.
Approving a filename is not enough when its contents can change. Binding approval to exact source versions makes the boundary meaningful. New evidence requires a new decision; an old “yes” should not silently authorize it.
Recovery is part of the workflow.
A useful system must handle corrections, not just the first successful run. Keeping receipts, marking dependent work stale, and reusing valid results makes a revision understandable instead of making everyone start from zero.
Where the prototype stands
Relay currently supports one workspace and a fixed invoice-review workflow. Guided demo mode uses real graph queries and tools, with deterministic explanation text; optional live-model runs are identified separately. Follow-up answers may omit report citations or overstate conclusions, so the generated reports and execution records remain important to inspect.
Read the verification recordFor a next iteration, the priorities would be stronger evidence citation in follow-up answers, durable hosted storage, and carefully adding workflow types. Each new action needs the same clear boundary: which evidence, whose permission, and what record remains afterward.
SEE IT COME TOGETHER
From the first question
to the final receipt.
The full walkthrough follows the company graph, Ripple, document evidence, Finance approvals, and a corrected invoice through to the existing case being resolved.
Video not loading? Open it on YouTube
The app requires a demo account and may need a moment to wake up on free hosting. Complete local setup instructions are in the repository.
OpenAI Codex and ChatGPT assisted with planning, implementation, testing, documentation, and this blog. Human direction shaped the product requirements, priorities, and demo feedback. Disclosure details