Beyond meeting summaries: live assistance during real conversations
A private copilot for conversations that runs on your device. Where the idea came from, how it's built, and the bug I uncovered during a long conversation.
Juarez Filho6 min read
I've used Granola for a long time. After an important call, I'd run the same recipe on my notes. It's called Look Again, it was made by Soleio, and Granola describes it like this: "Identifies surprising, deeper, and more incisive questions that could have been asked during the conversation."
What questions are you surprised were not covered in this conversation? What questions should I have been asking instead of the ones I posed? Great questions surface the crux of a matter—which questions could have cut deeper into the topic at hand? If we have 15 more minutes to discuss this further, what would have been the most incisive questions for us to tackle together?
It was always a little humbling. The questions were good. Some were better than the ones I'd actually asked. And every time I had the same thought: I wish I'd had this during the call.
That's where it clicked.
The question arrived too late
I've spent years leading customer conversations, user research sessions and workshops. The pattern never changed. I walk in with a goal, a list of topics and a few questions that really matter. Then the conversation starts, and I'm listening, thinking about what to say next, and trying to remember all of that at once.
Every conversation pulls you in different directions. You’re listening closely, planning your next question, and trying to track what’s been said. Somewhere in that shuffle, a detail gets missed or the one question you wanted to ask never gets asked.
That was the spark: what if a silent copilot sat beside you, held the map of where the conversation needed to go, and quietly nudged you while the moment was still alive?
Live customer interview. Tracking what to ask next.
Mapping call takeaways and questions left unasked.
Presenting prototype flows shaped by user feedback.
Rapid prototyping during a client Design Sprint.
Synthesizing patterns from recorded user calls.
What Sideprobe does
Sideprobe is a private copilot for conversations. It runs on your own device, a Mac today, and I'm starting on a Windows version soon. It listens along and helps you in the moment. No bots, no calendar invites. It works alongside Zoom, Meet or Teams, or sitting across from someone in a room.
While you talk, it can show you:
- a question worth asking now, based on what the other person just said
- a detail they left hanging, like a number, a date, or an incident the conversation moved past
- a claim stated as fact that nobody tested
- what this kind of conversation usually needs, like budget, decision-makers, or next steps, flagged only once something they said makes it relevant
Every one of those traces back to a real line the other person said. If it can't point to the line, it doesn't show up. A suggestion at the wrong moment is worse than no suggestion, so it's paced by the conversation, not by a timer.
When the conversation ends, the session and its summary land in a folder, one per client or project. You can ask a folder a question, and it answers from that folder only, so one client's context never leaks into another's. And there's Dictation, which turns speech into clean text wherever you're typing. That one is free, and will stay free forever.
What stays on your device
Transcription, telling voices apart, and the language models all run locally on your own machine. That's how the Mac app works today. The Windows version will hold the same privacy line, even though the libraries and architecture underneath will be different.
I want to be upfront about one thing: usage counts will be shared so I know how people are using the app, but nothing about what’s said leaves your device. That means anonymous signals like how many sessions you ran, how long they lasted, and what broke. During early access this is on for everyone, because without it I can't tell whether people actually use the app. At launch, it becomes your choice.
How it's built
I started a few months ago, as a side project.
Under the hood, a small language model runs on your machine and writes the suggestions. You don't set it up yourself: on first launch, Sideprobe checks what's installed and configures what's missing.
As for how I put the project together: I’m using Claude Code to develop the native experience for macOS and Windows, and the website is mostly Gemini inside of Antigravity IDE.
I also tried OpenCode on the native side, and it was a disaster. It's fine for small scripts and website tweaks. But native system work on macOS is unforgiving: audio capture, system permissions, and the low-level parts that talk directly to the hardware. That's where it fell apart for me, so I let it go. I might try it again later. These tools change every few weeks.
I'm keeping an eye on other models too. OpenAI's are incredibly good, so I may end up with a mix of Claude Code and the latest OpenAI models.
The silent bug that almost shipped
The most useful thing I did last month was test it on a real 100-minute conversation, with real notes, not a demo.
It went badly in six ways. I filed them all. One of them was that my Mac became unresponsive during the post-conversation summary, under the heavy memory usage of the local LLM calls. It turned out the bug only appeared when the conversation stretched beyond an hour, which I hadn’t anticipated. I dug into the logs, found the memory leak, and patched it so future conversations stay smooth.
But chasing it, I found something worse. The summary of that 1 hour 40 minute conversation cited nothing before the 1:04 mark. The model had read about a third of the transcript, and nothing told me. The code treated "this is too long" as a speed problem, when it was a coverage problem.
I'd have shipped that. The summary looked fine, but it was just missing most of the conversation.
It reads the whole conversation now, and on my Mac the summary of a conversation that long went from about six minutes to about two and a half. The whole process reminded me how crucial real-world testing is. The lesson I'm keeping is to measure before you decide what's wrong: I was half right, and the half I was wrong about was the one I felt most sure of.
Where it is today
It’s in early access, and the app works end-to-end with live help, folders, Ask, and Dictation features. It’s still rough in places, but it’s fully signed and ready for a simple click-to-open launch.
During early access, it’s free to use and I’ll share future plans once things are more concrete.
I’m opening up early access to gather real-world feedback and refine the app based on what people need. Building in public means I get to learn from your experience and improve it together before the full launch.
Get early access
Closing thoughts
Sideprobe grew out of years of leading customer conversations, user research, and workshops, and that familiar frustration right after they ended. Walking away to grab a coffee, heading into the next meeting, or going out for a run, the realization always hits: I should have asked that.
I wanted a way to catch those moments while still in the room, when asking the right question can actually change the outcome and get to those deeper insights together.
Got a story where the perfect question hit you only after the conversation ended? I’d love to hear your real-life examples below.
Questions come straight to my personal inbox. I read and reply to each one myself. Or if you'd rather share your thoughts directly with me or chat about Sideprobe, reach out on X (@juarezpaf) or LinkedIn.