Braid: Remembering the decisions you make with AI

A few weeks ago we went looking for why we picked Postgres.

We knew it had come up. We just could not find where, or what changed our minds two months later when we tore it out and moved everything to Firestore. The reasoning was in there somewhere, buried in a wall of chat history under a hundred other threads about caching, auth, and a bug that turned out to be a missing environment variable.

That is the thing nobody warns you about when you start building with an AI as your pair. You write code with it, sure. You also decide things. Which database. How auth works. Whether to build the login yourself or pay someone. Dozens of these, most of them settled in a couple of messages and then never written down anywhere a human would look again.

The chat remembers the messages. It forgets the decisions.

Braid is our attempt to fix that. We built it over a couple of weeks for a hackathon, and the idea is easy to say and was not easy to build: treat every decision you make with an AI as a real thing, with a state, a reason, and a receipt. Then draw them.

A commit graph for your reasoning

Git gave code a memory. You can see when a line changed, who changed it, and if you are lucky, why. Your reasoning gets none of that. It lives in prose and then it evaporates.

So Braid reads your exported chats and pulls out the decisions themselves, not the messages around them. Each one becomes a node on a graph where time runs downward and every column is a subject: database, auth, hosting, payments. A node that still holds is solid. One you reversed is struck through. A choice you were weighing but never settled hangs as an open fork. It looks like a commit graph, except the commits are things you decided instead of things you typed.

The first time we ran it on our own history and saw the Postgres node with a line through it and Firestore sitting above it, we actually felt something. There it was, the decision we could not find, and the message that made it was one click away.

Reading the chats

You drop in an export from Claude or ChatGPT and Braid runs a small pipeline of agents over it.

One agent groups related conversations. Another slices each thread into episodes. Then a writer summarizes each one, and here is the part we care about most: an auditor checks every claim the writer makes against the actual source text, and throws out anything it cannot ground in a real message. If the model paraphrases something into existence, the auditor catches it and drops it. A decision engine that hallucinates decisions would be worse than useless, so a lot of the build went into making sure it does not.

After that a second pass finds the decisions inside those summaries, works out which subject each one belongs to, and looks for the interesting cases: reversals, forks, things you committed to and never followed up on.

Early on this took about five minutes for twenty conversations, which felt terrible to sit through. The fix was boring and it worked. The slow parts were a bunch of independent model calls running one after another for no reason, so we ran them at the same time instead. The output was identical and the wait dropped to about a third.

Catching yourself contradicting yourself

This is the feature we would demo first.

Say you settle on Postgres in week one. Then in week four, staring at a requirement for live order tracking, you decide to switch to Firestore. Both are real decisions. Braid notices they are about the same subject and that the second reverses the first, marks the old one as superseded, and keeps the new one as what holds today.

It goes one step further, and this is the bit people do not expect. Back in week two you had set up connection pooling specifically because you were on Postgres. When Postgres goes, the reason for that pooling decision quietly dies with it. Braid flags it. Not "this is wrong," just "the thing this was based on is gone, you might want to look." That is the kind of loose end that normally surfaces three months later in production.

Every decision comes with a receipt

None of this is worth anything if you cannot trust it, so nothing in Braid is a claim without a source.

Click any decision and it opens the actual conversation it came from, with the exact sentence highlighted and the surrounding messages there for context. There is no summary standing in for the truth. You get the source itself. If Braid tells you "you decided to switch to Firestore for live subscriptions," you can watch yourself say it.

The banner that argues back

This is where it stops being a viewer and becomes a partner.

When you are chatting and you start to walk back something you already settled, Braid interrupts. You type "let's go back to Postgres" and a banner appears: you settled this on the 29th, here is the decision, here is the receipt. Two buttons. Keep, if you have genuinely changed your mind and want the new call recorded. Or re-open, which takes what you just typed and makes it the new decision, superseding the old one, with your own message as the receipt.

It is not nagging. It fires only on things you actually committed to, never on a passing thought, and stays quiet the rest of the time. But when it fires, it has saved you from silently contradicting a decision you forgot you made.

The questions only you can answer

Braid settles what it can and refuses to settle what it should not.

Some things are genuinely still open. You compared Cloud Run and Fly.io for hosting and never actually chose. You said you would add Stripe "next sprint" and then never mentioned it again. Braid does not pretend to know the answer to those. It collects them into a short morning list of questions only you can close, phrased plainly: you started reasoning about hosting but never decided, is it still open? You answer once, and it remembers your answer even after you re-import fresh data later.

Asking your own decisions

There is a chat where you can ask questions, and the answers are grounded in your decisions and nothing else.

Ask "what did we decide about the database" and it pulls the relevant decisions, writes a short answer from only those, and shows you the receipts underneath. Ask about something you never decided, mobile push notifications say, and it tells you plainly that it has no decision on that, instead of inventing a confident paragraph. We have come to trust the refusals as much as the answers.

What you said versus what you shipped

You can point Braid at a GitHub repo, and this is where it gets a little uncomfortable in a good way.

It reads your dependencies and your commit history and lines them up against your decisions. Where the code backs up what you said, the decision gets a confidence ring. Where it does not, you get a drift flag: you decided Postgres, your code ships MongoDB, here is the commit that did it. There is also a git hook that runs at commit time and warns you when what you are about to push contradicts a decision you already made. We think of it as reasoning CI. The idea that a commit could fail review for disagreeing with your own past self still makes us grin.

The weekly report, and a lesson about AI video

At the end of a week, Braid can turn your decisions into a short video.

We used Google's Veo for this, and it taught us something the hard way. Our first version asked Veo to animate the graph with the real labels and summaries on screen. What came back was beautiful and completely unreadable, every word a melted approximation of a word. It turns out generative video models cannot render text. You cannot prompt your way around it. It is a wall.

So we changed the approach. Veo now makes a purely abstract animation, glowing rails and nodes and reversals moving down the screen with no text anywhere, and the real, readable decisions live in a panel next to it. The video sets the mood. The words come from something that can actually spell. Once we stopped fighting the tool for something it fundamentally cannot do, it got good.

Architecture

[ Architecture diagram goes here ]

Under the hood, Braid is two pieces. A Python engine does all the real work: reading exports, running the agents, extracting and storing decisions, and serving everything over a small HTTP API. A React front end draws the graph, the ledger, the chat, and the weekly report on top of it.

The engine is built offline first. By default every model call is stubbed with deterministic output, so the whole thing runs on your laptop with no cloud account and no bill, which is how almost all of it got written and tested. Flip a single flag and the same code path calls real Gemini on Vertex for extraction and embeddings, with Firestore for storage and Veo for the video. Decisions are content addressed, so re-importing the same history does not create duplicates, and your answers survive across imports. The diagram above walks through how a dropped export becomes a decision graph.

What we would tell you if you were about to build this

Two things stuck with us.

The first is that grounding is everything, and it is boring work. The auditor that throws away unsupported claims is not a flashy feature and it was most of the effort, but it is the only reason the rest of the product is worth trusting. Cutting that corner would have made a demo that lies.

The second is to stop fighting your tools. We lost real time trying to make Veo render text before we accepted that it never would. The good version came from giving each tool the job it is actually good at.

Braid is not finished. Plenty of it is rougher than we would like, and the list of things we want to do next is longer than the list of things we have done. But it already does the one thing we built it for. When we go looking for why we picked something, the answer is there, with the receipt that proves it.

---