Graph Hacks · Team Graphable

We gave an AI on-call crew a FalkorDB brain. Switch the graph off, and it drops from 84% to 6%.

How we built Graphable for Graph Hacks: a crew of AI agents that finds the real cause of an outage, the person who can fix it and the fix that worked last time, by walking a FalkorDB graph of the whole company.

Graphable's incident view: the cause, the proof and who to call
Graphable's incident view: the cause, the proof and who to call

TL;DR


The 3 a.m. problem

It's 3 a.m. Payments are slow and twenty services are alerting at once. The on-call engineer needs three answers, fast:

  1. What changed? Dozens of changes landed in the last two hours. The newest one is the obvious suspect, and usually innocent.
  2. Who owns it? Teams reorganise. The new owner was announced in a chat message, not in the owner list.
  3. Who fixed this before? The answer sits in an old ticket, a postmortem, or one person's head, and that person may have left.

None of these answers lives in a single record. Each one depends on how things connect. That's what a graph database is for.

Why a graph?

Every question an on-call engineer asks is a walk across relationships:

QuestionThe walk through the graph
What breaks if redis-cache fails?follow DEPENDS_ON backwards, as of a point in time
Which change caused this?follow DEPENDS_ON forward from the alerting services to the components that changed
Has this happened before, and who fixed it?Incident → AFFECTED → Component ← AFFECTED ← past Incident → RESOLVED_BY → Person
Who owned checkout during INC-0287?OWNS relationships with valid_from / valid_to
Why did we decide ADR-001?Decision → DOCUMENTED_IN → Doc, → DECIDED_BY → Person, → SUPERSEDES → Decision

In a vector store these are fuzzy guesses; in SQL they're chains of recursive joins. In FalkorDB, each is one bounded Cypher query an agent can call as a tool, and most of ours answer in 15 to 50 milliseconds.

The graph

Graph data model
Graph data model

We generated a realistic but fully synthetic company, "Acme Commerce", with twelve months of history:

Loaded and extracted, that's about 41,000 nodes and 108,000 relationships. The history includes the messy parts of a real company: a reorganisation, departures, decoy deploys, silent root causes, look-alike incidents, stale runbooks and superseded decisions.

Two design choices made the graph trustworthy:

1. Facts are never deleted, only closed. Ownership, team membership and dependencies carry valid_from and valid_to. When a chat message says "from today checkout is owned by Orbit", the old OWNS edge is closed and a new one opened, with the message as its source:

// ownership as of any moment, with its source
MATCH (t:Team)-[o:OWNS]->(:Component {id: $id})
WHERE o.valid_from <= $at AND (o.valid_to IS NULL OR o.valid_to > $at)
RETURN t.name AS team, o.source_id AS source

2. The agents' memory lives in the same graph. Evidence, hypotheses, handoff notes, tasks, actions, lessons and conversation history are nodes too. That gives all three kinds of memory in one place:

The architecture

Architecture
Architecture

The core rule: the agents never touch the database directly. They call graph tools on a real MCP server, and every tool runs bounded, read-only Cypher on FalkorDB, with a timeout.

One incident, step by step

Here's the demo scenario "Repeat offender". Twenty services fail at once. Nine minutes earlier, someone changed an eviction setting on redis-cache, which raised no alarm itself. Five minutes earlier, someone rolled out a payments feature flag: the newest change, and a decoy.

Triage asks FalkorDB which alerting services everything else depends on, using its built-in PageRank:

CALL algo.pageRank('Component', 'DEPENDS_ON') YIELD node, score
RETURN node.name, score ORDER BY score DESC

It then measures the blast radius back to customer-facing entry points (valid at incident time), sets the severity, and writes a handoff note into the graph.

The Investigator walks from the alerting services to everything they depend on, up to five hops, and collects the changes that landed there:

// simplified: candidate root causes downstream of the alerting services
MATCH p=(a:Component)-[:DEPENDS_ON*0..5]->(c:Component)
WHERE a.id IN $alerting
  AND all(r IN relationships(p) WHERE r.valid_to IS NULL OR r.valid_to > $t0)
WITH c, collect(DISTINCT a.id) AS explains, collect(p)[0] AS path
MATCH (ch:Change)-[:CHANGED]->(c) WHERE ch.ts >= $t0 - $window AND ch.ts <= $t0
RETURN c.id, explains, path, ch.id, ch.kind, ch.summary

Each change is scored on signals that come from the graph:

The newest change explains none of it, so it's ruled out.

The evidence graph: the exact subgraph the agents used
The evidence graph: the exact subgraph the agents used

The UI shows the exact subgraph the agents' MCP tools returned, 44 nodes and 64 relationships:

The Responder finds the owning team, the person on call right now (OnCallShift → COVERS → Team, valid at incident time) and the person who actually knows the system. It computes that from fixes, postmortems, changes and tickets, and it warns that the bus factor is 1 because the other expert has left. Filing a ticket is automatic; waking a human up needs a human's approval.

Every step is an MCP tool call, with the Cypher it ran
Every step is an MCP tool call, with the Cypher it ran

Coordination you can trust

When many agents work at once, they must not duplicate work: nobody wants to be paged twenty times. Each coordination write is a single Cypher statement, so claiming a task is an atomic compare-and-set in the graph:

// simplified: only one worker can win the claim
MATCH (t:Task {id: $id}) WHERE t.status = 'SUBMITTED'
SET t.status = 'WORKING', t.owner = $worker, t.version = t.version + 1
RETURN t.version

Pages are MERGEd on an idempotency key. In our test, 20 agents raced for the same task: exactly 1 claim and 1 page.

A company brain that cites its sources

The same graph answers company questions, each answer citing its source:

Ask the Brain: decisions traced to their source
Ask the Brain: decisions traced to their source

Free-form questions go to Gemini, which chooses the graph tools itself over MCP. Every sentence must cite an evidence_id those tools returned; code checks it, and drops any sentence that doesn't.

Did the graph actually help? We measured it

We built 80 incidents with planted traps: decoy deploys, silent causes, look-alikes, multi-cause and non-change incidents. We tuned on 40 and froze the system before testing on the other 40, each on a fresh copy of the graph (FalkorDB's GRAPH.COPY makes that fast).

Right change ranked first
Right change ranked first

When every method has to name one change, following the graph gets 84% (27 of 32):

The real cause is in Graphable's top 3 in 88% of incidents, and it went 4 for 4 on look-alike traps.

But is it the graph, or just clever scoring? We switched off groups of signals on the same incidents:

Ablation: switch the graph off
Ablation: switch the graph off

Graph signals only: 84%. Time only: 6%. Removing the dependency paths or the incident history each costs about 15–18 points, while removing recency costs nothing. All the accuracy comes from relationships.

It also learns. A failure pattern it had never seen occurred 8 times: it got the first three wrong, an engineer corrected it each time, and the corrections were written to the graph. From then on it was right every time.

Learning a new failure pattern
Learning a new failure pattern
By the numbers
By the numbers

To be honest about the limits:

What FalkorDB gave us

What we learned

  1. Let the graph decide and the LLM explain. We tried letting Gemini overrule the graph's ranking; it fixed 1 incident and broke 3. Now a disagreement flags a human instead.
  2. Verify in code, not in prompts. Every claim cites evidence, and a few lines of code re-check each cited relationship. Hallucinated claims are shown as rejected and never acted on.
  3. Time is a first-class property. Bi-temporal edges turned "who owns this?" from a guess into a query, and made reorganisations safe.
  4. Coordination belongs in the database. Compare-and-set claims and idempotent MERGE gave us safe multi-agent work with no extra queue or lock service.
  5. Measure with traps. Without decoy changes, "blame the newest deploy" looks fine. With them, it scores zero, and the graph's value becomes obvious.

Try it

claude mcp add --transport http graphable-live https://graphable-api.onrender.com/mcp \
  --header "Authorization: Bearer dev-demo"

Then ask: "What breaks if redis-cache fails, and who should I page?"


Built for Graph Hacks (WeMakeDevs × FalkorDB) by team Graphable: Devanshu Saxena, Prins Kumar and Vaibhav Tyagi. We used Claude (Anthropic) as an AI coding assistant, as disclosed in the repository. All data is synthetic.