The Granola-and-Claude moment that started Jiva

I ran a meeting recorder and an AI side by side for months before I saw what they did together. Then I hit the same wall three times, and the wall turned out to be the product.

I'm a product manager in Bangalore, and my team is in New York, so most of my day is calls. The problem was never that I didn't have notes. The problem is that by the end of the week I've lost track of who committed to what, and I have no record I actually trust enough to go back and check.

For a while I solved this in two separate pieces. I used Granola to record my meetings, and I used Claude to do the thinking around them — writing specs, working through problems, turning rough notes into a first draft. Two different habits, and they never really met.

Then one day, instead of typing out a summary of a meeting for Claude, I gave it the actual transcript of what was said and asked my question on top of that. The answer was noticeably better.

The model had not changed. The input had.

That is the whole insight, and it is easy to miss. Most people try to improve the output by improving the prompt. The bigger lever is the context you give it. A good model with thin context gives you a generic answer; the same model with the real conversation gives you something specific and actually useful.

So I leaned into it, and almost immediately ran into a wall. Then I hit the same wall two more times, in different places.

The same wall, three times

First, I could not trust who said what. The moment there were more than two people on a call, the attribution started breaking and lines got assigned to the wrong person. Note that a record of who said something that you cannot trust is worse than no record at all, because you will act on it anyway. If I cannot trust the attribution, the transcript is useless for the exact thing I wanted it for.

Second, the transcript was locked in. The most valuable thing I had was the raw conversation, and that was the one thing I could not cleanly get out. When I connected the recorder to Claude over its MCP connector, on the free plan what came through was the summary and the notes, not the full transcript of what was actually said. So the scheduled tasks I had set up on top of it were running on thin, second-hand material and never did what I designed them to do. The summary was the part I could write myself; the part I could not reproduce was exactly the part the tool kept inside.

Third, there was no way to talk to it. Getting my own thinking into the AI still meant typing, and when I type I clean the thought up before it leaves my head. When I speak, the messy reasoning comes out too — and the messy part turns out to be the useful part, because it is the context the model cannot guess.

Three problems, one root cause. Working with AI is bottlenecked on how fast and how accurately you can give it context, and speaking is the fastest way a human does that. Note that this means the thing I actually wanted was never really a notetaker.

What I wanted was a context pipe: capture everything I say and hear, attribute it correctly, keep it as plain files I own, and let any AI read it.

Why it had to be local

There was one more thing I could not get past, and it was less a feature than a feeling. The more useful my archive of conversations became, the less comfortable I was with it sitting on someone else's servers. The material that makes AI useful to me is the same material I least want to upload — real decisions, real numbers, real people talking openly.

I work with firms where "your conversations get uploaded to a vendor's cloud" is a hard no, so I know this isn't only my concern. Keeping everything on my own machine was not a positioning choice. It was the only version of the product I would actually use, which felt like a fair test of whether it should exist at all.

So I started building the missing pieces

I should be clear about what that sentence hides: I am not an engineer. Every line of Jiva has been written with an AI, and working out how to do that responsibly — on real systems software, with real audio and real failure modes — is at least half of what I want to write about here.

That is where this starts. Jiva is a fully-local second brain for the Mac. It records both sides of your meetings, transcribes them on the device, learns who said what across time, and hands the whole thing to whatever AI you use, with nothing leaving your laptop. It is free, and you can download it at jiva.works.

The product is one half of why I'm writing. The other half is the question at the top of this page — whether one person, building only with AI, can get a fully-local tool to a level that stands next to what much larger teams ship. I don't have the answer yet. What I have is a dated decision log, a running list of things that broke, and a lot of specifics. So that is where I'll start.

More soon — including the first thing that broke.