Rowboat: The Open-Source AI Coworker That Actually Remembers

Every conversation with most AI assistants starts from zero. You re-explain who Alex is, what project Phoenix involves, why you’re meeting with the board next week. It’s the re-explanation tax we all pay for using AI that treats every interaction as a blank slate.

Rowboat takes a fundamentally different approach: it builds a persistent knowledge graph from your actual work, emails, meetings, documents, and uses that accumulated context to help you get things done. The difference isn’t subtle. It’s the difference between an assistant and a search engine.

The Memory Problem in AI Assistants

Context windows have gotten larger, 128K, 200K, even a million tokens, but that doesn’t solve the memory problem. A bigger context window just means you can paste more documents each time. You still have to feed it everything manually.

The real issue is structural: most AI tools use search-based retrieval. When you ask a question, they search your emails or documents, reconstruct context on demand, and hope they grabbed the right pieces. Next session? Same process, cold start.

This works for one-off questions. It breaks down for ongoing work where context accumulates. You don’t want to explain who reports to whom every time. You don’t want to re-attach the same project document. You want an assistant that already knows.

That’s what knowledge graphs enable: explicit, long-lived memory that compounds instead of resetting.

How Rowboat’s Knowledge Graph Works

Rowboat connects to Gmail, Google Calendar, and meeting note tools like Granola and Fireflies. As you work, it processes your emails and meetings to extract what matters: people, projects, decisions, commitments, open questions.

These get stored as an Obsidian-compatible vault of plain Markdown files with backlinks. Each person becomes a note. Each project becomes a note. Relationships are explicit: “Alex mentioned the Phoenix launch timeline in the 2026-02-28 sync” becomes a backlink you can follow.

Here’s what makes this powerful:

It’s transparent. Open the ~/.rowboat/vault directory and you’ll find actual Markdown files you can read. Want to see everything related to a particular client? Check their note. Want to edit something the AI got wrong? Just edit the file.

It’s local-first. Nothing leaves your machine unless you explicitly connect external tools. Your email history, meeting notes, and knowledge graph live on disk. No cloud lock-in, no proprietary format.

It compounds. Every email adds context. Every meeting adds relationships. A month in, Rowboat knows your org chart, your active projects, who’s waiting on what. Six months in? It knows more than you consciously remember.

The vault is Obsidian-compatible, so you can open it in Obsidian and navigate the graph visually. You’ll see clusters form around projects, timelines emerge from meeting sequences, and decision threads you forgot existed.

Practical Use Cases: Where Memory Actually Matters

Meeting Prep That Knows Your History

You have a 1:1 with Alex in 20 minutes. Ask Rowboat to prep you. It doesn’t just look at today’s calendar event, it pulls:

• Past decisions from your last three meetings
• Open questions that never got resolved
• Emails exchanged since you last talked
• Action items Alex committed to

The result is a crisp brief (or a voice note, if you’ve configured Deepgram for voice synthesis) that surfaces what actually matters. You walk into the meeting informed, not scrambling through Slack threads.

Email Drafting Grounded in Commitments

Draft a reply to a client asking about timeline. Rowboat doesn’t guess, it checks your knowledge graph:

• What did you promise in the last email?
• What did the team commit to in the internal sync?
• Are there blockers mentioned in recent threads?

The draft it generates references actual context. It doesn’t hallucinate commitments you never made or timelines you can’t hit. This alone saves the “wait, did we agree to that?” verification step that eats 10 minutes per email.

Follow-Ups That Don’t Get Dropped

After a meeting, Rowboat can extract:

• Decisions made
• Action items assigned
• Owners for each deliverable
• Deadlines mentioned

These get written back into the knowledge graph. A week later, when you ask “what’s the status on the Phoenix launch tasks?”, it pulls from the graph instead of making you dig through meeting transcripts.

Background Agents for Recurring Work

This is where it gets interesting. Rowboat can spin up background agents, automated workflows that run without you asking every time.

Examples from the repo:

• Daily voice briefings: Every morning at 8am, generate a voice note with your agenda, priorities, and upcoming meetings, grounded in your knowledge graph, not generic calendar summaries.

• Email reply drafts: When emails arrive, draft replies in the background and save them as notes. You review and send, but the first draft is already written.

• Recurring project updates: Pull the latest emails and notes about Project Phoenix, generate a status update, save it to your vault. You edit and share it, but the synthesis work is done.

The agents run locally, with explicit permission controls. They can’t send emails or take actions without your approval, they draft, prep, and organize, then hand back control.

Setting It Up

Download the latest release for Mac, Windows, or Linux from rowboatlabs.com/downloads or GitHub releases.

Google integration: Follow the Google setup guide in the repo to connect Gmail, Calendar, and Drive. This uses OAuth, Rowboat never sees your password, and you can revoke access anytime.

Bring your own model: Rowboat works with whatever LLM setup you prefer:

• Local models via Ollama or LM Studio (privacy purists, this is your path)
• Hosted APIs (OpenAI, Anthropic, etc.) with your own API key
• Swap models anytime, your data lives in the Markdown vault, not the model

Adding tools via MCP: Rowboat supports the Model Context Protocol, so you can plug in external tools without writing custom integrations. Want web search? Add Brave or Exa. Want voice output? Add ElevenLabs. Want to connect your CRM, Slack, Linear, or GitHub? There’s probably an MCP server for it.

The MCP design means you extend functionality through configuration, not code. Add a tool, point Rowboat at it, and the background agents can use it.

Rowboat vs. Traditional AI Assistants

The comparison breaks down along three axes:

Cold retrieval vs. compounding memory:
Traditional: Search your emails → reconstruct context → answer question → forget everything.
Rowboat: Maintain knowledge graph → query structured memory → answer with history → remember for next time.

Hosted vs. local-first:
Traditional: Your data lives in their cloud. You trust their encryption, their compliance, their business continuity.
Rowboat: Your data lives on your machine as plain Markdown. You control backups, access, and deletion. If Rowboat the company disappears tomorrow, your vault still works.

Generic vs. context-aware:
Traditional: “Draft an email to Alex.” (Who’s Alex? What’s the context? Guess.)
Rowboat: “Draft an email to Alex.” (Checks graph: Alex is your engineering lead, last met 2026-02-28, discussed Phoenix launch blockers, committed to timeline update by Friday. Drafts accordingly.)

The context-aware path doesn’t just save time. It changes what’s possible. Background agents that draft meeting preps only work if they know who you’re meeting with and what’s been discussed. That requires memory, not search.

Who Should Use This

Ideal for:

• Business owners juggling multiple client relationships and projects where re-explaining context kills productivity
• Teams handling sensitive data that can’t leave their infrastructure (legal, healthcare, finance)
• Knowledge workers drowning in email and meetings who need an assistant that learns from work already done
• Privacy-conscious professionals who want AI assistance without cloud lock-in
• Automation enthusiasts comfortable with terminal tools and local infrastructure

Probably overkill if:

• You have three emails a week and one meeting a month
• You’re happy pasting documents into ChatGPT for one-off questions
• You don’t want to run anything locally (though Rowboat can use hosted models, it still runs on your machine)

The sweet spot is ongoing, relationship-heavy, context-rich work where the re-explanation tax is real.

The Local Execution Advantage

Because Rowboat runs on your machine with shell access, it can do things cloud-based assistants can’t:

• Generate PDF slide decks using local tools
• Create files and organize your vault
• Automate browser tasks (with explicit permission)
• Run scripts and workflows that touch your filesystem

This power requires careful safety design. Rowboat implements command-level allowlists and deny lists, with containerization on the roadmap. Every action is reviewable before it runs. The threat model isn’t perfect, local execution gives the agent real capabilities, but the transparency and control beats black-box cloud processing for many use cases.

Open Source Means You Can Verify

Rowboat is Apache 2.0 licensed. The entire codebase is on GitHub. That means:

• You can audit what it does with your data
• You can modify it for your specific workflow
• You can contribute integrations and tools
• You’re not locked to the vendor’s product roadmap

For organizations with compliance requirements, this matters. You can run Rowboat in your environment, verify the code, and control exactly where data flows.

The Compounding Effect

Here’s the thing about knowledge graphs: they get more useful over time. The first week, Rowboat knows what you told it. A month in, it knows your org structure and active projects. Six months in, it’s mapped relationship histories, decision threads, and patterns you don’t consciously track.

That’s the shift from “AI that answers questions” to “AI that knows your work.” The re-explanation tax disappears. The context switching cost drops. The assistant becomes actually assistive.

Traditional RAG-based tools don’t compound this way. They search the same corpus better, but they don’t build structure. Rowboat builds structure, and structure scales.

Try It for a Week

The real test is simple: use it for a week. Connect your email and calendar. Let it build the knowledge graph. Then ask it to prep you for a meeting or draft an email.

You’ll notice the difference. Not because the LLM is smarter, but because it has the context to be useful. That’s what persistent memory buys you.

Download: rowboatlabs.com/downloads
GitHub: github.com/rowboatlabs/rowboat

The difference between an AI that knows your context and one that doesn’t is the difference between an assistant and a search engine. Rowboat is an assistant.

Word count: ~1,480 words

Internal link opportunities:

• Link “Model Context Protocol” to upcoming MCP executive guide
• Link “command-level allowlists and deny lists” to AI agent security best practices article
• Link “privacy-conscious professionals” to any existing content about local-first tools or data sovereignty