The graph the agents built
WardAtlas is a Company Brain for hospital operations, built on FalkorDB in four days on a 4 GB laptop. Most of its code was written by LLM agents running in a workshop I set up on a laptop home server, and I directed and checked them. That makes it a useful thing for the people who build FalkorDB to look at: a project that shows how well LLMs write against FalkorDB, and where they still need a human.
The question underneath the hackathon
The brief for Graph Hacks was context for AI agents: give an agent a graph and see what it can do. There is a second question hiding inside that one, and it matters to a database company just as much. If agents are going to be the ones writing code against your database, how good are they at it?
Most projects can only answer the first question. WardAtlas can say something about both, because the agents built it. 121 of its 127 commits are authored by Agent Workshop. The other six are mine: final-day redesign, docs, the live demo link and the agent on top. Every Cypher query in it was written by a model and then checked against a live FalkorDB before it was accepted.
MATCH clausesThe workshop
The setup is a Dell Inspiron laptop running Ubuntu as a home server, with 4 GB of RAM. On it I built a small agent workshop: OpenCode running OpenAI GPT models as planners, builders and reviewers, each in its own lane with its own ports and its own throwaway graph. A supervisor dispatched work and a panel let me watch it.Under full load the laptop reached its 95 °C thermal trip and powered itself off on the last day. The fix was a CPU cap and a dispatch guard, which is the least glamorous lesson here and possibly the most practical one.1
The rule that made it work was simple: contracts before code. Every feature started as a written contract with frozen expected results and an adversarial matrix, committed before any behaviour existed. A builder could only land work by passing those checks against a real FalkorDB 6.0.2, started fresh from a digest-pinned module, on a run-unique graph that was deleted afterwards.
- A planner writes the contract and the expected outputs.
- A builder writes the Cypher, the service and the UI.
- A verifier seeds a new graph, runs the queries, mutates edges and checks that answers change exactly as the contract says.
- I read what came out, kept what was good and sent back what wasn't.
A budget laptop as a data centre
Everything in this project ran on one machine: a Dell Inspiron 3502 laptop with 4 GB of RAM, plugged into a wired college network. No cloud VM, no GPU, no Docker. The same box already runs my document archive, photo library, media server, backups and a couple of small web services, so the hackathon had to fit in whatever was left.
That constraint shaped every decision, and I think it made the project better.
- FalkorDB without Docker. The verifiers pull the official
falkordb/falkordb:6.0.2image straight from the registry, check the index, manifest and layer digests, check the module's SHA-256, and load the.sointo a plainredis-server. You get the exact official build with no container runtime. - A standard-library app. The whole product is Python's standard library talking RESP to FalkorDB. Nothing to install and nothing to go out of date overnight.
- Room made on demand. While the agents worked, the box's other services were paused to free memory. Each agent lane got its own port range and its own throwaway graph, so many builds and verifications could share one small machine safely.
- Public from a laptop. The live demo is served from this laptop to the open internet through Tailscale Funnel, on real FalkorDB, and reseeds itself every 12 hours. No load balancer, no hosting bill.
It wasn't always graceful. The laptop's firmware stops at a power-adapter warning after a reboot, so a restart needs a person at the keyboard. On the last day the agents pushed the CPU to its 95 °C thermal trip and the machine switched itself off mid-build. I brought it back, added a CPU cap and a guard that holds new work when it runs hot, and the swarm carried on.
The point isn't that the hardware was bad. A graph database that runs, together with its app, in well under 100 MB beside a fleet of agents, on a machine most people would retire, is a strong argument for FalkorDB on its own.
How strict the checking was
Speed is easy to get from agents. Trust is the hard part, so most of the engineering went into verification. There are 11 contract packets and 47 verifier scripts. A few of the frozen suites, all run against a live FalkorDB with desktop and mobile browser checks:
The tests don't just check that answers look right. They attack them. They delete a single supporting edge and require the answer to become unknown rather than silently wrong. They connect restricted evidence directly into the graph and require the visible answer to stay exactly the same. They shift one source's timestamp by a minute and require the replay to change at exactly that minute. They reconnect with a fresh client, reseed, and check nothing drifted. Expected results were committed before the code they judge, and their hashes are checked so nobody, human or model, can quietly move the goalposts.
What the agents were good at
The short answer is Cypher. Models have read a lot of openCypher, and it shows. The core question of the product, an outage happened; who is affected and who owns the response, is a five-hop path, and the agents wrote it as one readable pattern:
MATCH (i:Incident {id:'INC-204'})-[:AFFECTS]->(e:Equipment) -[:SUPPORTS]->(s:Service)-[:SERVES]->(d:Department) -[owns:OWNED_BY]->(r:Role)-[:EVIDENCED_BY]->(src:Evidence) WHERE owns.current = true AND owns.source_id = src.id RETURN d.id, r.id, src.id, src.observed_at
The real query is longer because it filters an access property on every node and every edge, and joins a dated source to each hop. The agents kept that discipline across more than two hundred MATCH clauses, because the contracts failed any query that let a restricted source change an answer.
Three things about FalkorDB made it a good target for agents:
- It speaks Redis. The app talks to it with a tiny standard-library RESP client and
GRAPH.QUERY. No driver, no dependency tree for a model to get wrong. - Graphs are cheap. Every verifier run made its own named graph and removed it with
GRAPH.DELETE, so parallel agent lanes never stepped on each other. - It is light. The database and the app together use under 100 MB on a 4 GB laptop, with no Docker. That is what let the workshop run many lanes at once.
Where a human still mattered
The agents were fast, careful and sometimes dull. The idea was mine: a Company Brain for a hospital, where the hard part is who owns this right now rather than what does this document say. So were the graph ideas the agents built from:
- trace impact from an incident to an accountable role;
- put a dated source behind every hop;
- keep contradictory SOPs side by side instead of picking a winner;
- use two clocks, one for when something took effect and one for when it was known.
Taste also stayed human. On the last day the frontend looked like every other generated dashboard, so I had it rebuilt from scratch with Claude Code, which also recorded the demo film and deployed the live demo. The agents could satisfy a contract. They could not tell me the product looked cheap.
The graph did the remembering. The contracts did the checking. I did the deciding.
Then I gave the graph to an agent
On the final day I added the piece the brief asked for directly: an LLM agent whose only context is the graph. It cannot see the database. It can call seven WardAtlas tools, and every one of them is a live FalkorDB query: trace the outage, read the two-clock shift board, replay what was known about the SOP decision, draft a handover. Saving the handover asks a human first.
Asked “Conveyor C4 went down at 18:30Z. Who is affected, who owns it, and what should I flag before handover?”, the model made three graph calls and answered with the two affected departments, the roles on those paths and a warning that the two SOP versions still disagree, each claim tagged with a source ID and the time that source was observed.gpt-6-luna on Azure OpenAI, run against the public live demo. The transcript is in the README.2 It did not invent an owner, and it did not pick an SOP. The graph made the honest answer the easy one.
What FalkorDB can take from this
If you want to know how well LLMs work with FalkorDB, this repository is a fairly direct measurement. Agents wrote the schema, the seeds, the Cypher and the tests, and a live FalkorDB held all of it to account. They were good at Cypher and at the Redis-shaped interface. They stumbled where the database left them to do things by hand:
- Time. Every effective-time and known-time filter is hand-written. Native “as of” support would remove a whole class of bugs.
- Permissions. An
accesscheck on every hop works, but one forgotten clause leaks data. Built-in label or property-level access control would make the safe query the default. - Setup. Loading the module bare-metal on Redis 8 failed until the
.sowas marked executable, and the error didn't say so. Agents read error messages literally, so clear errors help them more than they help people.
The broader point is that the people who write code against a database are increasingly not people. A database that is easy for an agent to query, isolate and verify against will get more of that code. FalkorDB is already most of the way there.