Last year our council spent the better part of 6 months discussing and figuring out what do about a serious EV charging infrastructure issue in the parking garage of a 430 unit property. There were technical / electrical plans reviewed and discusssed, developer documentation, owner complaints, multiple vendors with multiple quotes. Somebody’s brother-in-law knew a guy. Everyone on council had a strong opinion and a point of view. We discussed it in our monthly meetings and went back and forth over email for a long time. When we finally got our heads around the problem and figured out a way forward, we tabled it once, and the finally voted.
If you asked me today why we went down the path we did, I could probably reconstruct it. But it would take me hours in my inbox, and I’d get half of it wrong.
Here’s the thing that took me a while to see clearly. All of that, the quotes, the brother-in-law, the hundreds of emails about it, the back-and-forth, moved through software. It moved through email. What didn’t happen is any of it landing in a system built to hold it. The only thing that got recorded in any durable, findable way was the motion itself. One line. The decision, without a shred of the discussion that produced it.
And the discussion is the part that actually matters. Not just what we decided, but what we weighed, what we ruled out, the objection someone raised that turned out to be right. That’s the part a future council needs, and it’s the part that survives least well.
I think about this a lot now, because I’m building software for exactly this problem, and the whole AI industry is currently telling itself a story that doesn’t fit what I actually see on a council.
The Story the Industry Is Telling
The pitch going around right now, and it’s a good one, is that the way to build AI that actually understands an organization is to sit inside the software where the work gets done. Be the tool where the ticket gets closed. Be the system where the approval gets clicked. Capture the decision at the exact moment it commits, with all the context still in the air. Foundation Capital wrote a whole thesis on this and called the result a context graph. The argument is basically: whoever owns that moment of capture owns the memory, and everyone else is just picking through the wreckage afterward.
The word for that moment of capture is the write path. You’re there when it’s written. And the argument is that the write path is where all the value is, because reconstructing a decision after the fact from whatever residue got left behind, the read path, is lossy and second-best.
I mostly agree with the argument. It’s right about a lot of software. Where a decision really does flow through one authoritative system, an agent that sits in that system and catches the decision as it commits is genuinely better than piecing it together later.
I just think the picture inverts in governance, for a reason that’s easy to miss. It’s not that these decisions skip software. It’s that the reasoning around them never flows through a system built to capture it, and the reasoning is the part that matters most.
There’s No System for the Part That Matters
Go back to the EV decision. Where exactly would an AI have sat to capture it write-path? The write path assumes there’s one authoritative system the decision flows through, so you can sit in it and catch the decision as it commits, reasoning and all. But there’s no such system here. The vote happens in a meeting. The reasoning that led to it is spread across dozens of email threads, almost as many attachments, side conversations, and loads of messages from an owners with opinions. It moved through software, plenty of it, just not through anything built to hold a decision.
The systems these groups actually run on, the property management platform, the accounting software, the document store, record outcomes. The motion passed. The invoice got paid. The contractor got hired. They’re outcome ledgers. They were never designed to hold the reasoning, and the reasoning never flowed through them to begin with. It flowed through email, which holds everything and structures nothing.
So when someone says “sit in the system and capture the decision at the source,” my honest reaction from four years on a council is: which system? The decision commits in a room. The reasoning that produced it, the thing you’d actually want, is scattered across general-purpose correspondence that no capture point sits astride. There’s a mention worth making that some of that correspondence is part of the formal record and can matter if a decision is ever challenged, but you don’t need the legal angle to see the problem. The context is what a future council needs, and it lives in the least structured place there is.
And I’m not the only one who thinks the capture-at-source story is harder than it sounds, even in the enterprise world it was written for. Dharmesh Shah, HubSpot’s CTO, called the context-graph idea elegant and intellectually compelling and then landed a reality check: most companies are nowhere near ready to instrument their systems for it. His line stuck with people. Asking companies to capture decision traces when they’re still getting their basic data in order, he said, is like asking someone to install a three-car garage when they don’t own a single car. Sanjeev Mohan, a former Gartner analyst, put it more bluntly and predicted the industry will spend 2026 debating context graphs without actually building them.
Here’s the part I find genuinely telling. Even the people making the write-path case admit where the reasoning currently lives. Foundation Capital’s own writing concedes that these decision traces stay trapped in unstructured formats, conversation transcripts, email chains, undocumented exceptions, that no system can index or query. That’s not a footnote. That’s the whole ballgame. They’re describing the exact material a council runs on, and calling it the thing nobody has captured yet.
Which Flips the Thing, at Least Here
Once you see that, the read path stops being the consolation prize and starts looking like the foundation.
In a domain where the reasoning genuinely flows through one system, read-path reconstruction really is second-best. You’re picking up fossils when you could’ve been standing there watching it happen. But governance isn’t that domain. The email threads and the opinionated messages about the EV chargers aren’t a lossy trace of some richer record kept elsewhere. They are the record. The reasoning lived there and nowhere else. Reconstructing from correspondence isn’t a weaker version of capturing at the source when the correspondence is the source.
I want to be careful here, because it would be easy to overstate this. I’m not claiming the write path is impossible in governance or that it’ll never matter. It will. Meetings are moving onto Zoom and getting transcribed. Some platforms will start hosting board meetings directly. Over time, more of the decision moment will happen on some kind of digital surface, and some of it will get captured cleanly. But that shift is going to be gradual, uneven, and partial for a long time, probably forever. It won’t arrive as a clean all-or-nothing flip where suddenly the decision commits neatly inside one system with its reasoning attached. Councils turn over. Firms change software. Half the real reasoning still happens in the hallway and the side conversation, and people speak more freely precisely when they know it isn’t being recorded. Governance is never going to hand you a tidy write path.
Which is the actual point. Because write-path capture will only ever be partial and slow to arrive, the read path isn’t a phase you pass through on the way to something better. It’s the layer underneath that has to hold everything together while capture slowly, unevenly improves. You reconstruct from the mess you have today, and as cleaner signals show up, meeting transcripts, structured minutes, the occasional real system integration, you fold them in. But they land on top of a reconstruction layer, they don’t replace it. Get the read path wrong and there’s no clean write path waiting to save you, because in this domain there isn’t going to be one. Get it right and it’s the thing every future signal attaches to.
Why This Matters if You’re Not Me
If you sit on a board or a council, you already know the actual cost of this. It’s the moment someone new joins and asks why the reserve fund is structured the way it is, and the only person who knew retired two years ago. It’s the manager who leaves and takes ten years of “here’s why we don’t use that vendor anymore” with them. The record technically exists. It’s scattered across inboxes that have changed hands three times. The knowledge didn’t get destroyed. It just stopped being findable the moment the person who knew where to look walked out the door.
Every group like this loses its memory the same way, over and over, and everyone treats it as just how it works. I did too, for years, until I was the last one left in a meeting who remembered why we’d decided something, and realized that was a stupid way to run anything.
The AI conversation right now is mostly about being present at the moment of capture. But for a lot of organizational life, the part worth capturing was never a single moment in a single system. It’s the reasoning, and the reasoning is spread across correspondence that no capture point sits astride. So the more interesting question, at least for the world I know, isn’t only how to catch the decision as it commits. It’s how to reconstruct the thinking behind it from the scattered trace it leaves, and how to keep doing that as those traces slowly get richer.
That’s the problem I’m working on. Not because reconstruction is the fallback when capture fails, but because in governance it’s the foundation everything else has to stand on.