How the most decisive decision of my life led to building the Decisive Agent

I’m the most anxious person you’ll ever meet, so I built an AI that makes my decisions. Then everything broke.

A love story between a girl who can’t decide, a graph database, and about forty things that went wrong.


Chapter 0: The girl who couldn’t decide

I’m 20. I am, with great confidence, the most anxious person you could find around.

I overthink what to eat. I overthink whether I’m being a good friend. I overthink the thing I decided yesterday, and then I regret it, and then I overthink the regret. Every tough decision comes with its own little shadow: what if I picked wrong?

And most days, under all of it, there is one tiny, tired thought:

Can’t someone just tell me the right thing?

Not a stranger. Not a quote. Someone who actually knows me. Someone who knows I’ve been off sugar for ten days straight and says, “Go on. Have the sweet. You earned it.” Someone who watches me spiral about a misunderstanding with a friend and says, “Let this one go,” or, “No, this one is worth a conversation.”

I didn’t want an assistant that answers. I wanted one that decides, and remembers who I am while it does.

Chapter 1: The most decisive thing I’ve ever done

Then I saw the FalkorDB hackathon.

Now, the old me would have opened the page, closed it, opened it again, made a pros-and-cons list, asked three friends, and missed the deadline in a cloud of “maybe next time.”

This time I made one decision, fast, with no list:

I’m doing it. And I’m building the thing I wish I had.

That is the real origin of this project. The most decisive choice of my life is the reason Decisive exists. A girl who couldn’t decide, deciding to build a machine that can.

I called it the Decisive Agent. I didn’t know yet what that sentence would cost me.

Chapter 2: The problem nobody warns you about

I started thinking about what this thing would need to be, and I hit a wall almost immediately.

Real people change. Real life is not a spreadsheet.

  • A friend I trusted a week ago turns out to be a snitch. Everything the agent “knows” about that friendship is now wrong.
  • I watch one YouTube video about what’s actually in Oreos, and I never want to eat them again. Yesterday I loved them. Today they’re banned.
  • I turn vegetarian. Last month I said I eat meat. Both sentences are in my history. Only one is true.

Most AI memory just adds. It piles new facts on top of old ones and never lets go. So tomorrow, the agent that’s supposed to help me gets confidently wrong, because yesterday’s me is still voting.

That’s worse than forgetting. That’s a friend who remembers you perfectly... as someone you stopped being.

I didn’t need a bigger memory. I needed a memory that knows what’s still true, and that understands facts are connected: this advice exists because of that fact, and if that fact dies, the advice has to die with it.

Connected. Facts connected to facts.

That’s a graph.

Chapter 3: The day I met FalkorDB

I was thrilled that something like FalkorDB exists. A graph database, where the links between things are first-class, not an afterthought. Suddenly the whole idea clicked into place:

Nothing is ever deleted. But only what is true now is allowed to touch an answer.

Every fact is a node with a life: active, superseded, retracted, or invalidated. When I say “I turned vegetarian,” the old fact isn’t erased; it gets a SUPERSEDED_BY edge to the new one and stops counting. When I say “that was wrong,” the fact is retracted, and everything built on it goes with it.

Here’s where FalkorDB did the real work.

The read guard. The agent is only allowed to read facts through one door:

MATCH (f:Fact)
WHERE f.status = 'active'
  AND (f.ttl_days IS NULL OR f.valid_from + f.ttl_days > $day)
RETURN f.key, f.value, f.id

Only three files in my whole codebase may even type MATCH (f:Fact), and a test fails if a fourth tries. A stale fact can’t sneak into an answer by accident.

Cascade. “Avoid paneer wrap orders” exists only because I once said I hate paneer wrap. If that was a mistake, the avoidance has to go too. One traversal:

MATCH (f:Fact {id:$id})<-[:DERIVED_FROM*1..6]-(d:Fact)
WHERE d.status = 'active'
SET d.status = $st, d.valid_to = $day
RETURN d.key

Time travel. Because every fact knows when it started and ended, “what did you believe about me on day 8?” is a single query:

MATCH (f:Fact {key:$k})
WHERE f.status <> 'retracted' AND f.valid_from <= $day
  AND (f.valid_to IS NULL OR f.valid_to > $day)
RETURN f.value ORDER BY f.seq DESC LIMIT 1

Receipts. Every decision is a node linked to the exact facts it used. A shortestPath from me to the decision is the audit trail, and the website draws it as a graph you can click. When the agent tells me to eat the sweet, I can see why, which, for an anxious person, is half the cure.

PageRank ranks my goals, so the one I keep working on outweighs the one I mentioned once. And every person gets their own graph, so two memories can never leak into each other.

Chapter 4: Headdown. (Everything that broke, in order)

Okay. You want to hear how it really went. Here’s the hall of fame.

💥 The database wouldn’t even install. The embedded FalkorDB I started with doesn’t build on Windows. So I moved the whole thing into WSL. Then I decided I wanted the real FalkorDB server, not the lite one, so I installed Docker, which promptly told me it couldn’t be found. (I stared at a PATH error for longer than I’d like to admit.)

💥 My laptop ran out of space. At one point my C: drive had half a gigabyte left. Docker started failing in strange ways, and then the image itself came out corrupt, full of NUL characters instead of code. I freed up space, did a factory reset, pinned a specific version of the image, and tried again. A computer being too full to think is, I realised, very relatable.

💥 My own rule caught me. I’d written a test that says only three files may read facts. Then my own code, a little helper script, broke the rule. My guard, guarding against me. I was weirdly proud.

💥 My tests were too easy, and that scared me. My first batch of test questions passed everything, and a test suite that never fails is a liar. So I did something slightly evil: I injected 7 bugs on purpose (a wrong threshold, a disabled cascade, the guard removed) to see if my tests would notice. They caught only 4 of 7. The other three sailed through. I had to rebuild the question generator to aim at close calls. Now it catches all seven. That was the day I stopped trusting “all green.”

💥 Two agents, one memory, total chaos. I wanted several agents to share one person’s memory over MCP. When I hammered one slot with 8 threads at once, I got 111 “active” facts in a slot that should have exactly one. A graph doesn’t stop you from making a mess! I fixed it with a lock, a repair step that keeps the replaced-by chain a straight line, and an atomic claim so two agents can never grab the same job.

💥 It worked perfectly... except on Linux. Inside Docker, three things broke that never broke on my laptop: a multiprocessing deadlock, an MCP server that couldn’t find the database (the client was hiding my environment variables), and output so buffered that the whole thing looked frozen for minutes. Running everything in a container found all three.

💥 My agent thought a normal sentence was a crisis. I’d taught it to spot genuinely worrying messages, which matters when a girl is typing her feelings into a box. Then “hit me up” (as in, text me) set off the alarm. Whoops. Fixed.

💥 I taught it to learn, and it got worse. I wanted the agent to learn from how its advice turned out. My first version rewarded good outcomes and punished bad ones equally, and accuracy dropped. It only works if it learns from its mistakes. (There’s a lesson in there about me, and I’m choosing not to look at it directly.)

💥 The tool that wouldn’t stop returning pieces. One of my MCP tools returned a list, and the library delivered it as a pile of separate blocks, so my two-agents handoff demo just... hung, politely, forever. I rewrapped the result and made the demo fail fast instead of waiting.

💥 And then, the website. I opened my first interface and was not convinced. It looked like a developer’s debug console, full of words like slot and valid_from, and nobody anxious at 2 p.m. wants to read that. I redesigned it again and again until it felt like something a person could use: a landing page with the problem told as a story, answer cards that say why, a memory timeline with a time-travel slider, and a graph that lights up the exact path behind any answer.

Chapter 5: Render, midnight-ish, and a boyfriend

Now the part I’m going to remember forever.

The code worked. The tests passed. All that was left was to put it on the internet where a judge could click it.

My boyfriend had been waiting, patiently and then less patiently and then very sweetly, for me to finish this. I kept saying “ten more minutes.” I said it a lot.

I pushed to GitHub and clicked Deploy on Render.

It asked for my card. Because I’d put the database on a paid plan. I decided (decisively!) that nobody was getting my card, and rebuilt the whole deployment to run FalkorDB inside the web service, on the free plan.

It built. It deployed. It crashed. Exited with status 127. sh: python ui_server.py --host 0.0.0.0 --port 10000: not found. The server was running my entire command as one long, hopeful program name. After a lot of squinting, I stopped telling it how to start and made the app read its own port from the environment instead.

Then it just... didn’t respond. For a while. A free server that goes to sleep, a progress bar, a boyfriend gently asking if I was alive.

And I thought: not long ago I couldn’t pick a lunch without a committee. And here I was, on deadline night, with a failing deploy, not giving up. Calmly fixing the next thing. One decision at a time.

(Which is, I realised, exactly what the Decisive Agent is for. I’d just been using the human version.)

Aftermath: what I actually built

Here’s the thing I’m proudest of, said plainly:

I built an agent whose memory is a FalkorDB graph, where every fact has a life, every answer comes with receipts, and nothing stale is ever allowed to speak.

I measured it against a checker that’s separate code from the engine, on 3,595 questions the engine had never seen while I was building it:

DecisiveA “newest write wins” memory
Questions answered correctly3,595 / 3,5952,828 (78.7%)
Stale facts used0648

On 1,417 questions about friends, Decisive matched the checker every single time (the simple memory: 79.4%). With 16 memories running at once on one database: zero leaks between people. 299 tests passing, on the real FalkorDB server, inside Docker, on Linux.

And what does it feel like? You say, “I turned vegetarian,” and it says, “Got it, you’re vegetarian now.” You ask what to order, and it doesn’t pick the chicken you loved last month. You say a friend cancelled on you again, and it says, “Let this one go: it’s the first time in 60 days. If it happens again soon, that’s a pattern worth raising.”

It’s not magic, and I want to be honest about that. All the data is synthetic. I wrote both the engine and the checker, so zero disagreements means they agree, not that my rules are the right rules. The advice principles are my own design, not checked by a psychologist. And it only knows 44 foods, which means that today it does not know the Oreos, which is its own little heartbreak. It’s on my list.

What I learned (the real stuff)

  1. A memory that never forgets isn’t the goal. A memory that knows what’s still true is. Keeping history is easy. Keeping history out of the answer is the hard part.
  2. A graph earns its place when the links are the product. “Replaced by,” “built on,” “used by”: once those are edges, cascade, time travel, and audit become short queries instead of mountains of code.
  3. Prove it against something that can tell you you’re wrong. The most valuable thing I built wasn’t a feature. It was a way to be corrected.
  4. Show your work. Seeing the facts behind a decision made me trust it, and use it more.
  5. Decisions don’t need to be perfect. They need to be made. I built an AI to decide for me, and somewhere around the Render crash, I noticed I’d been doing it myself all night.

Try it

👉 Live demo: https://decisive-q525.onrender.com

👉 Code and the full evaluation: https://github.com/ishwaryaaaaaaaaa/GraphyAgents

Start with a blank memory. Tell it one thing about you. Then ask it something and click “See how I decided.”


A note on how I built it: I worked with an AI coding assistant (Claude Code) to write much of the code and tests. I made every design decision, every trade-off, reviewed what it produced, and made every commit myself. The product itself doesn’t need an LLM: its decisions come from readable rules and graph queries.

And to my boyfriend, who waited: it’s done. Dinner’s on me. I’ll even decide where.


 

Comments