I built a rocket lander with no neural network: its entire brain is a graph database
For the Graph Hacks hackathon I replaced an AI agent's neural network with a FalkorDB graph running on AWS. It learned to land a lunar lander 94% of the time, explains why it crashes, and fails completely the moment you delete its memory. Here's what I built and what I learned.
A few days ago I knew almost nothing about graph databases. This weekend I used one to build an AI agent with no neural network at all. It was one of the most fun and eye-opening things I've built, and I want to share what I learned along the way.
The problem: agents that can't explain themselves
When you train an AI agent with reinforcement learning, it usually ends up as a neural network: a big block of numbers. That block can do the job, but it can't tell you anything about it. When the agent fails, you can't ask it why. You retrain it and hope.
That always bothered me. So for Graph Hacks (a hackathon by WeMakeDevs and FalkorDB), I asked a simple question:
What if the agent had no neural network at all, and everything it knew lived in a graph I could open and read?
That became crashgraph.
What crashgraph is
crashgraph is a lunar lander. It uses Gymnasium's LunarLander physics (Box2D), completely unmodified, so its scores are directly comparable with any other agent on the same problem.
The difference is the pilot. It has no weights and no model file. Instead:
- Before every engine decision, it asks its memory: "what happened last time I was here?"
- After every attempt, it writes down what happened, good or bad.
That memory is a FalkorDB graph. The policy is the graph.
[Screenshot: the main Flight screen with the lander, the live card and the live memory map]
Three kinds of memory in one graph
This was the part that really changed how I think about AI memory. One graph can hold three different kinds of memory, and they can all be queried together:
- Procedural memory: 108,061 "skill tiles". Each one stores how good each engine action is in a particular state. This is the part the pilot reads to decide what to do.
- Semantic memory: 1,744 situations (like "low altitude, drifting left, tilted right") and 8,775 transitions between them. Crash risk is calculated by following these connections.
- Episodic memory: every attempt the lander has ever flown, linked to the exact path of situations it went through.
A neural network can only really hold the first kind. The other two are naturally a graph: things connected to other things.
[Screenshot: the Graph Memory panel showing the learning chart and the memory numbers]
Did it actually learn?
Yes. It started at 0% landings. After 3,743 attempts, it now lands 94% of the time. Every one of those attempts was generated by the agent itself. There's no borrowed dataset: it flies, writes down what happened, and that becomes the data.
Watching the red-to-green strip of attempts fill in, one by one, was honestly my favourite part of the whole project.
The test I'm proudest of: delete the brain
Showing a nice graph next to the agent is easy. Proving the graph is actually doing the work is harder. So I built a test that runs right in the UI:
| Run | Landings out of 30 |
|---|---|
| With memory | 26 |
| Memory wiped | 0 |
| Memory restored from a snapshot | 26 (identical scores) |
The snapshot uses FalkorDB's
GRAPH.COPY. With the same seeds and the same graph, you get exactly the same flights, down to the digit. Wipe the graph and the lander can't fly at all. There's nowhere else for the skill to be hiding.[Screenshot: the removal test results]
Asking the agent why it crashed
Because the policy is data, you can ask it questions. Click any crashed attempt and it tells you:
- the point of no return: the first moment the attempt was very likely doomed
- how often past attempts failed from that same situation
- what the successful attempts did instead
Each answer comes with the Cypher query that produced it, so nothing is a black box. I also used graph algorithms as tools: PageRank finds the situations that funnel attempts into crashes, and label propagation groups them into "failure families".
There's also a heatmap that folds every situation onto height and distance from the pad. It makes something obvious visible at a glance: low and over the pad is safe, low and off to the side is where attempts stop being recoverable.
[Screenshot: the "Where it goes wrong" heatmap and a crash explanation]
Three worlds, one database
FalkorDB can hold many isolated graphs in one instance, so each world gets its own memory:
- Moon: calm, standard gravity (the training ground)
- Mars: stronger gravity and crosswinds
- Titan: low gravity and heavy turbulence
Because skills are just nodes, I could copy the Moon agent's skills into Mars and Titan, and those agents started competent instead of from zero.
[Screenshot: the Analysis page with the learning chart per world and the worlds table]
Running on AWS
The graph runs on FalkorDB Cloud on AWS (ap-south-1, Mumbai), which keeps latency low from India. That matters here: the lander reads its memory about 50 times a second while it flies, so the database is literally inside the decision loop.
What I learned
- Graphs are a natural fit for agent memory. Situations, transitions and attempts really are "things connected to things". Modelling them as a graph felt obvious once I saw it.
- Explainability comes for free when the policy is data. I didn't have to bolt explanations on afterwards. I just had to write the right query.
- The best proof is a removal test. If your agent claims to use memory, try deleting it. If nothing changes, the memory wasn't doing anything.
- You don't need to be an expert to start. I came in with almost no graph database experience. Cypher is readable, FalkorDB Browser lets you see your data, and the hackathon pushed me to explore something genuinely new.
Built with
- FalkorDB on FalkorDB Cloud (AWS ap-south-1)
- Python and Gymnasium (Box2D physics)
- Three.js for the 3D control room
- Claude as an AI coding assistant
Thanks to WeMakeDevs and FalkorDB for running Graph Hacks. This was a new area for me, and I came out of it with a completely different way of thinking about how AI agents can remember.
Code: [GitHub link]
Demo video: [YouTube link]
Demo video: [YouTube link]
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article