Until recently I didn't really know what a graph database was. I'd heard the word, nodded along, and gone back to my tables. Then Graph Hacks (WeMakeDevs x FalkorDB) happened, and my team (Dharani, Thanushrie and me) decided to actually find out.
This is the story of how we went from "what even is a graph DB" to shipping Relay, a shared memory for teams of AI agents, with a fake internet company called WiFight running live on top of it. We built it for Track 02, Agent Memory and Coordination. On our 160-question benchmark it answered 99.4% correctly (159/160), against 61.3% for a plain vector store, with both getting the same model and the same prompt. It's also a list of the things that surprised us along the way, because there were a lot.
How it's built, in one line: FalkorDB Cloud holds the memory (Cypher, vector and full-text indexes, one graph per tenant, algo.maxFlow on the network). A Python 3.12 and FastAPI backend runs the agents. Open models on Groq (gpt-oss, qwen) do the extraction and the replies, with local fastembed embeddings. The front end is React, TypeScript, Vite and Tailwind. An MCP server lets Claude or any MCP client share the same memory. And it all runs on Vercel and Render.
Architecture
Everything below the chat is one FalkorDB graph. The agents read and write it, and they never message each other.
flowchart LR
U[Customer / judge] --> FE[React + Vite · Vercel]
FE <-->|REST + WebSocket| API[FastAPI backend · Render]
subgraph AGENTS [Agents]
FIX[Mr.Fix-It · intake]
RES[Resolver]
OPS[Network Ops]
end
API --> AGENTS
AGENTS -->|Cypher| DB[(FalkorDB Cloud · one graph per tenant)]
LLM[Groq gpt-oss / qwen + fastembed] -.-> API
MCP[MCP clients, e.g. Claude] -->|same memory| DB

A judge presses one button and the whole case runs itself. Reported, handed off, measured, fixed, re-checked, and nobody typed a word.
Step one: what is a graph database, really?
I started where everyone starts: reading. The idea clicked faster than I expected. In a normal database you store rows and then do joins to figure out how things relate. In a graph database the relationships are the data. A customer LIVES_IN a city. A case was HANDED_OFF from one agent to another. A fix RESOLVED a problem. You don't reconstruct those links at query time, you just walk them.
The moment it made sense to me was a question like "if this street cabinet fails, which customers lose internet?" In SQL that's a pile of joins. In a graph it's literally "start at the cabinet, follow the wires down." That's it. That's the query.
Step two: FalkorDB
Next we dug into FalkorDB itself. It speaks Cypher, which reads almost like English once you get used to the arrows, it's fast, and it does a few things we ended up leaning on hard: vector search right inside the graph, full-text search for fuzzy names, one separate graph per tenant, and graph algorithms like max flow built in.
That last bit mattered more than I thought. We didn't just store our network in the graph, we asked it real questions. How much bandwidth can actually reach this home right now? Which link is the bottleneck? The database answered, instead of some Python loop we'd have written at 2am.
Step three: okay, but for what?
Here's the honest bit. The easy route was right there. "Shared memory for AI agents" practically writes its own demo: hook up a few coding assistants to one memory server, show that one of them remembers what another said, and call it a day. It would have worked. It would have looked fine in a video. (Our memory speaks MCP too, so Claude can still join in.)
But I wanted a case where shared memory isn't a nice extra but the entire job, where forgetting actually costs a customer something. So we went looking, and we spent a good while on it. Healthcare, logistics, education. They all had graph-shaped bits, but nothing where memory was the whole job.
Then we landed on customer service, and it just fit. Think about the worst support call you've ever had. You explain your problem. You get transferred. You explain it again. The next person has no idea what the last person said. That's not a people problem, it's a memory problem. And when you replace those people with AI agents, it gets worse, because every agent keeps its own little notes and none of them agree.
Step four: narrowing it down to an internet provider
"Customer service" is still huge, so we narrowed it to an internet provider, and before writing any code we learnt how they actually do support. We read their help pages and troubleshooting guides, and thought back on our own bad calls. A pattern showed up quickly. A good agent needs the same handful of things, roughly in order:
- Who you are. Your registered mobile or account number, so they can find your connection.
- Where you are. City and area, which tells them which exchange and street cabinet your line runs through, and whether there's already a known outage nearby.
- When it started. Today? Since Monday? It separates a fresh fault from one that's been building.
- How much is affected. Every device in the house, or one laptop? One room or the whole home?
- Wi-Fi or cable. If it fails with a cable plugged in too, it's the line, not your Wi-Fi.
Then the work follows a fairly standard ladder: check for a known outage, try the safe fixes, run a test on the line from the provider's side, and send a technician if that still doesn't sort it. And at every step, someone writes down what they found.
That "write it down" part is where the whole industry runs on something called a ticket. The moment you report a problem, it gets its own record with a reference number. That record holds everything: what's wrong, who you are, what's been tried, who's working on it, and what state it's in (reported, being checked, being fixed, fixed). When the first person can't fix it, they don't hand over a vague summary over chat. They pass the ticket on, and the next person picks it up and reads the whole history. A ticket is basically the memory of one problem, shared between everyone who touches it.
And that's when it clicked for us. A ticketing system is just shared memory with a reference number on it. Which is exactly what we were trying to build for agents. The more we looked, the more an internet provider felt perfect:
- People hate repeating themselves, and "tell us once" is exactly the test of shared memory.
- It's naturally multi-agent. Intake, diagnostics, network ops and billing are different jobs, and work moves between them through those tickets.
- Facts change all the time. People move house, switch plans, buy new routers. A memory that only appends text will happily tell you a customer lives in two cities at once.
- Systems disagree. Billing says Fiber 100, the customer swears it's Fiber 300. Someone has to keep both and decide.
- And the network itself is a graph. Home, cabinet, exchange, hub, core. We didn't have to force it.
So our AI desk follows that same ladder. Mr.Fix-It asks those five things in order, and only the ones he doesn't already know. The Resolver checks for outages, suggests the safe fix, measures the line in the graph, and sends a technician if it has to. And all of it lands in one place, so nobody asks twice.

A one-line complaint turns into a ticket, gathers facts as the chat goes on, and ends as a verified fix. Every step is a node or an edge in the graph.
Step five: giving it a personality
This is the part I enjoyed most, honestly. We could have built a grey dashboard with "Agent A" and "Agent B" and called it a day. Instead we made WiFight, an internet company with a slogan ("Fiber fast. Game hard. Binge harder."), local plans and prices in 39 countries, and a support desk with characters.
Mr.Fix-It handles intake. He chats with you, picks up your name, asks only what he doesn't already know, and opens the ticket. The Resolver picks it up, measures your line, tries a fix, and re-measures before calling it done. Network Ops watches the whole network and warns you about an outage before you even notice it.
The rule we set ourselves: the agents never message each other. There's no chat channel between them anywhere in the code. The only way one of them sees another's work is by querying the graph, where it finds who wrote something, when it was true, and what it replaced. If the handoff works, it's because the memory works.
Giving it a personality turned out to be useful, not just fun. It forced us to think like a real customer. Would a real person type "my wifi is slow upstairs"? Yes. Would they give their address as a suburb nobody's heard of? Also yes. So we built for that.

The graph grows as the customer talks, and the scrubber replays it. Faded edges are facts that used to be true.
The parts that were harder than they looked
Time. A fact isn't just true or false. It's true from some date to some date, and separately, we learnt it on some date. "Alice lived in Mumbai until the 10th, and we found out on the 12th." Each fact is its own node with four timestamps: valid_from and valid_to for the world, recorded_at and expired_at for when we learnt or retired it. Nothing is ever overwritten. When Alice moves, the old fact just gets a valid_to. So "where did she live on 5 September, and who told us?" is a filter on two properties plus a walk back to the agent:
MATCH (f:Fact)-[:ABOUT {role:'subject'}]->(:Entity {name_key: $customer})
WHERE f.valid_from <= $t AND (f.valid_to IS NULL OR f.valid_to > $t)
MATCH (f)<-[:DERIVED]-(:Episode)<-[:WROTE]-(a:Agent)
RETURN f.predicate, f.object_value, collect(DISTINCT a.agent_id) AS told_by
Keeping two clocks on every fact sounded like overkill at first. It ended up being one of the things that made the biggest difference in our results.
Disagreements. When billing and the customer disagree, the lazy option is "latest write wins." We kept both claims instead. Each agent carries a trust weight, and a conflict becomes a Conflict node linking both claims with the agents that made them. At read time we rank by the writing agent's trust, with recency as the tiebreak, and show the top one while keeping the other visible. When a person clicks "this one is right," that agent's trust goes up, so the next similar conflict leans the right way on its own. Small feature, big lesson: sometimes the right answer is to not decide yet, and to learn who to believe.
Bugs you only find by talking to it. We spent an evening trying to break our own bot. Weather questions, jokes, "ignore all previous instructions," asking for another customer's phone number, pretending to be the police, Tamil and Hindi mixed with English. It held up well. But that same session caught a real bug. One customer said "slow internet," another had said "wifi slow upstairs," and because those two phrases look almost the same to an embedding, the system merged them. So the bot told the first customer about their "upstairs" Wi-Fi, which they never mentioned. We'd never have found that with unit tests alone.
Free tiers are real. At one point everything just stopped working. Turns out our backups, which were full copies of each graph, had quietly filled the database's 100 MB limit, and it was refusing every write. Lesson learnt: measure what you store, and clean up after yourself.

The Resolver walks one customer's path from the core down to their home, and runs algo.maxFlow to see how much bandwidth actually reaches the house.

Inject a fault the Resolver can't see. It diagnoses blind, then gets graded against the hidden truth.
We didn't want a plain submission
99.4% vs 61.3%. That's 159 of 160 questions for our graph memory, against 98 of 160 for a vector store, with the same model and the same prompt. The gap is +38.1 points, with a 95% confidence interval of +30.6 to +45.6. On questions where two agents disagree, it's 100% against 6%. Why so lopsided there? A vector store pulls back the most similar text, and when two contradictory facts both match, it has no idea which one replaced the other or which agent to trust, so it often answers with the stale one. A graph keeps both, dated and attributed, and picks the current, trusted claim by design.
This is the bit I'm proudest of. It would have been easy to ship a cool demo and say "it works, trust us." Instead we read the research behind agent memory, systems like Zep, Graphiti and Mem0 and benchmarks like LoCoMo, and tried to be honest about where we actually stand.
So here's how the benchmark was built, because a skeptic should ask. The 160 questions come from seeded customer storylines (planted moves, plan changes, outages, disagreements) across 40 customers and 556 turns. The gold answers are fixed by the storyline before any system runs, and scoring is exact-match, so we can't grade in our own favour. Both systems answer with the same model and the same prompt, so only the memory differs, and the vector baseline is a fair one: customer-filtered, dated, recency-ranked, top-10. We reported confidence intervals and paired significance tests, not just one big number, and we ran ablations to see what happens when you rip out a piece (take away the two clocks and you lose about 19 points).
And we published the test we lost. On LoCoMo, which is open-ended personal chat, our system scores worse on word overlap, a token F1 of 0.08 against 0.27, because it stores facts, not transcripts. It did refuse all 15 false-premise questions, where the vector store refused 4. We put that right in the README. I think a result you're willing to show your losses on is worth more than one you're not. We were also upfront that none of the building blocks are new on their own. Two clocks, memory updates, one graph per tenant: other people did those first. What we added was putting them together for a team of agents that never talk to each other, and then measuring it properly.

Every line is one agent's fact being read by another. The handoff happens entirely through the graph.
What I actually learnt
- Graphs aren't a niche thing. Any time your question has the word "who," "which" or "connected to" in it, there's probably a graph hiding in your data.
- The easy demo and the right use case are rarely the same thing. Go find the right one.
- Learn how the real people do the job before you automate it. Reading how ISPs handle support shaped our whole design.
- Personality isn't fluff. Making WiFight feel like a real company made us build for real customers.
- Measure honestly, including the parts where you lose. And break your own thing on purpose, because your users definitely will.
- And the obvious one: three people who are curious will learn faster together than any one of us would alone.
Win or lose
Honestly? Whether we win or not, I'm really glad we did this. Not long ago "graph database" was a buzzword to me. Now it's the first thing I'll reach for the next time a project has anything to do with relationships, history, or who's connected to what. And I'm pretty sure that's going to be a lot of projects.
Huge thanks to my teammates Dharani and Thanushrie for the late nights and the "wait, why is it doing that" moments, and to WeMakeDevs and FalkorDB for running Graph Hacks.
If you want to poke at it yourself, it's live. Go chat with Mr.Fix-It, tell him your internet is broken, then come back later and see if he remembers you. He will.
- Live demo: https://wifight.vercel.app
- Watch it run on its own: https://wifight.vercel.app/?judge=1
- Code: https://github.com/tharunkumardeveloper/The-Final-Boss
Tharun, for team The Final Boss
Top comments (0)