where-is-gpt-6-Sol@nkiessays · graphs · agents
Essaygithub.com/edwardEsmerson/ward-atlas

The graph the agents built

created18 Oct 2026 statusfinished confidencelikely forGraph Hacks · FalkorDB

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.

121/127commits by agents
200+Cypher MATCH clauses
47verifier scripts
4 GBRAM, one laptop

The 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 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.

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:

120assertions: decision knowledge timeline
86assertions: evidence watch
85assertions: evidence time machine
78assertions: Ask WardAtlas

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:

  1. 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.
  2. 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.
  3. 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:

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:

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.

All data in WardAtlas is synthetic and non-clinical.Live demo · Source