Rowboat: The Local-First AI Coworker (2026)

TL;DR

Rowboat is a free, open-source (Apache-2.0) desktop app for Mac, Windows, and Linux from YC-backed Rowboat Labs. It reads your email, meetings, Slack, and chat history, turns them into a local knowledge graph, and gives you dedicated surfaces — email, notes, browser, meetings, code — to act on that memory. Four things worth knowing before you install it:

• Your data is local by default. Notes, meeting summaries, and the knowledge graph itself are plain Markdown files on your disk, not a hosted database.
• The model is not, by default. Point Rowboat at a local model via Ollama or LM Studio, or bring a hosted API key — switch anytime without losing your data.
• MCP is one extension path among several. Rowboat connects to Exa, Slack, Linear, GitHub, ElevenLabs, and more — some through native Model Context Protocol (MCP, the open standard that lets an agent call external tools) support, some through a bundled tool platform called Composio.
• “Local-first” needs a footnote. Voice and web search call cloud APIs by default, and the maintainers said so themselves on Hacker News — see the section below before you assume zero network calls.

What Rowboat is

Rowboat is an open-source desktop application that builds a persistent, local knowledge graph from your email, meetings, Slack messages, and AI conversations, then exposes that memory through built-in “work surfaces” — an email client, a note-taking app, a browser, a meeting notetaker, and a coding environment — so an agent can act on your actual context instead of whatever you paste into a chat box. It’s built by Rowboat Labs, a Y Combinator S24 company, and ships under the Apache-2.0 license.

Rowboat’s own July 2026 Show HN post titled itself “Open-source, local-first alternative to Claude Desktop.” That framing is true as far as it goes — Rowboat can replace your chat window — but it undersells the product. Read past the headline and Rowboat looks more like a self-hosted bundle of an email client, an Obsidian-style notes app, a browser, and a coding orchestrator, all wired into one memory layer. “Alternative to Claude Desktop” is the pitch that fits in a launch title; “AI coworker platform” is the more accurate one, and it’s the framing this guide uses.

The founders’ own explanation, from that same post: “Claude’s desktop app is brilliant, but for our own daily work we kept wanting it to be less like a chat app and more like a full-fledged work app.” The lesson traces back to a previous startup building support-rep tooling for enterprise teams — including support desks for P&G brands — where live call notes and suggested replies taught the founders that “it’s not enough for the AI to be right, the help has to show up where the work is happening.” Work surfaces are that lesson, generalized to your own inbox and calendar.

The rest of this guide walks through how the pieces fit, what the community pushed back on, and how Rowboat compares to Anthropic’s own answer to the same problem, Claude Cowork.

Mental model: the five pieces

Five named pieces make up Rowboat. Once these click, the rest of the product is detail.

The graph is the constant. Everything else — which surface you’re in, which model is answering, which tool it calls — reads from and writes back to that same set of Markdown files. That’s the actual design bet: memory as the platform, not the chat window.

See it work

Rowboat’s own demo, verified against its official YouTube channel, shows the work-surfaces and code-mode combination in action:

Rowboat Work Surfaces: describe a workflow, get an app built into your work

RowBoat (YC S24) · click to play

Two concrete examples make the mechanic real. From the README: the built-in email client sorts incoming mail into important versus everything else, and pre-drafts responses to the important ones using accumulated work context — then keeps learning your voice as you edit and send. From a Rowboat team member’s own r/selfhosted post: ask “build me a deck about our next quarter roadmap” and Rowboat pulls priorities and commitments straight out of the knowledge graph, loads a presentation skill, and exports a PDF. Neither example requires you to re-explain who’s on the team or what the roadmap already contains — that context is already sitting in the graph.

Deep dive: the knowledge graph

Most AI tools reconstruct context on demand — they search your transcripts or documents fresh, every session. Rowboat’s README calls this out directly: “the result is memory that compounds, rather than retrieval that starts cold every time.” Instead of search-on-demand, Rowboat indexes email, meetings, Slack, and assistant conversations into a living, Obsidian-style backlinked knowledge graph — organized around people, projects, organizations, and topics, per a Rowboat team member’s r/LocalLLaMA post.

That same post describes the mechanism: background agents convert raw data into linked notes while performing entity resolution (merging every mention of the same person or project into one node), and an agent retrieves the relevant nodes before it acts, instead of re-scanning everything from scratch. Every node is a Markdown file with backlinks — readable, editable, and greppable with tools you already own.

Our take: this is the actual bet, and it’s the right one. A knowledge graph that compounds is a real advantage over a chat history that resets — assuming entity resolution holds up as the graph grows, which is the part no outside review has stress-tested yet.

Deep dive: the work surfaces

Six surfaces ship today, each reading from and writing back to the same graph:

Email

The built-in client sorts incoming mail into important and everything else, then pre-drafts responses for the important ones using accumulated work context. It watches how you edit and send, and drafts get closer to your voice over time, per the README.

Meeting notes

A local, Granola-style notetaker that taps your mic and speakers, produces a live transcript, and writes a Markdown summary back into the knowledge graph after the call — updating the relevant people, project, and topic nodes automatically.

Browser

An isolated browser, separate from your daily one, so you only log the assistant into accounts you actually want it touching. It navigates sites on your behalf using browser-use-style skills.

Code mode

Spin up parallel coding agents — Claude Code or Codex — and either drive them directly or let Rowboat orchestrate them with your work context. Rowboat built its own client for ACP (Agent Client Protocol, the wire format between an editor and a coding agent) to do this — the same protocol family covered in our ACP vs MCP explainer.

Notes & Apps

An Obsidian-style local notes system with a graph view, a bases view (structured, database-like note collections), and voice notes; it can also sync Google Docs for editing inside Rowboat. On top of all of it, “Apps” let you build custom work surfaces that inherit every tool and integration Rowboat has — publish one as a GitHub repo and register it for the community to install.

Background agents

Underneath the surfaces, background agents run on a schedule (“every day at 8am”) or a trigger (“new email”), and can call tools, search the web, use the browser, or write code, per the README’s own description.

Our take: Apps are the most ambitious, least-proven piece — a small extensibility platform nested inside a product that’s itself young. Everything else here is a fairly conservative, well-scoped feature set.

Deep dive: bring your own model

Rowboat doesn’t ship its own model. Point it at a local runtime — Ollama or LM Studio, both covered in our local LLM runtime comparison (Rowboat also has a catalog entry at /servers/ollama) — or bring a hosted API key from whichever provider you use. Swap anytime; because your notes and graph are plain Markdown independent of any model, switching providers doesn’t strand your history the way changing chat apps usually does.

One detail surfaced only on Hacker News, not in the README: local models get special handling. Per Rowboat cofounder segmenta, background agents are deliberately suppressed while you’re actively chatting with a local model, “so local models aren’t overwhelmed.” That’s a real tradeoff — a local model buys you privacy and zero token cost, but you give up some of the background-agent parallelism a hosted model gets by default.

Our take: this is the right default. Local inference is genuinely slower and more memory-constrained than an API call; throttling background work instead of pretending otherwise is honest engineering.

Deep dive: MCP integration

MCP (Model Context Protocol) is the open, JSON-RPC-based standard that lets an AI client call external tools and pull in outside data — our What is MCP explainer covers the wire format in depth. Rowboat treats it as one extension point among several, not the headline feature: the README’s own MCP section frames it plainly — “plug in (for example) search, databases, CRMs, support tools, and automations — or your own internal tools.” Named examples include Exa for web search, X/Twitter, ElevenLabs for voice, Slack, Linear/Jira, and GitHub.

The documented mechanism is concrete but thin: drop an API key into a config file under ~/.rowboat/config/, one file per service, every file using the same shape:

{
  "apiKey": "<key>"
}

External tools specifically go through ~/.rowboat/config/composio.json — Composio is a hosted tool-integration platform that proxies a wide catalog of connectors, MCP-compatible ones included. The README says you can also “add any MCP server” through the same mechanism, but doesn’t show the JSON shape for registering an arbitrary custom server the way claude_desktop_config.json does — treat that path as functional but under-documented until the repo says otherwise.

Our take: correctly scoped. The knowledge graph and the surfaces are Rowboat’s product; MCP is plumbing that widens what the surfaces can reach. If you already have a favorite server from our directory, expect to wire it through Composio rather than find a bespoke Rowboat recipe for it.

Is it actually “local-first”?

This is the question the community asked loudest, and it deserves a straight answer instead of marketing copy. On Hacker News, the pushback was immediate:

A follow-up from mrbluecoat captured the underlying worry: “I’m always nervous pointing any AI tool at my email, browser, and finances. Any similar solution that’s truly local-first?” Rowboat cofounder segmenta answered directly, in the same thread:

Both things are true at once, and it’s worth separating them. Data-local-first checks out: your emails, notes, meetings, and the knowledge graph itself are plain Markdown on your disk, readable and deletable with tools you already own, and the app doesn’t need Rowboat’s servers to run. Compute-local-first is conditional: the LLM only stays on your machine if you choose Ollama or LM Studio, and voice and search are cloud calls by design — a tradeoff the team says it will revisit “if there’s demand.” Analytics (PostHog) is metadata-only, opt-out by omitting the env vars, and catalogued in the repo’s own ANALYTICS.md, per segmenta’s reply.

Worth flagging: Rowboat’s own marketing isn’t fully consistent on this point. A February 2026 r/selfhosted post from a Rowboat team member described the app as “designed to be fully self-hostable with no cloud dependency” — a stronger claim than the founder’s own HN answer months later. Both that thread and a companion r/LocalLLaMA post drew a lukewarm reception from their respective communities, which tracks — self-hosted and local-LLM audiences notice this kind of gap fast. Evaluate the data claim and the compute claim separately and you won’t be surprised either way.

Install & first run

Rowboat is a desktop app, not an npx package — there’s no install command to run against an existing MCP client. Download the build for your OS from rowboatlabs.com/downloads or the GitHub releases page (Mac, Windows, and Linux are all supported), install it like any desktop app, and open it.

First-run connections matter more than the install itself, since the knowledge graph is only as useful as what feeds it. Connect Gmail, Calendar, and Drive by following the project’s Google setup guide; Slack, Linear, GitHub, and other one-click integrations are available from inside the app.

Everything past that is optional, and all of it follows the same pattern — drop an API key into a JSON file under ~/.rowboat/config/:

Skip any of these and Rowboat still runs — you lose only that specific feature, not the core app. Point the model setting at Ollama or LM Studio for a fully local LLM, or add a hosted provider’s API key; either way, your Markdown vault stays put.

Rowboat vs Claude Cowork

The comparison is invited, not just editorial framing — one of Rowboat’s own demo videos is titled, verbatim, “Rowboat – Cowork meets Obsidian.” Our full Cowork breakdown covers Anthropic’s side in detail; here’s how the two actually differ.

Our take: pick Cowork if you want zero setup and you’re already committed to Claude — Anthropic’s sandboxing and polish are hard to match with an open-source project. Pick Rowboat if model choice or literal data ownership is non-negotiable, and you don’t mind running — and occasionally troubleshooting — a desktop app yourself. They aren’t really competing for the same buyer: one is a managed product, the other is infrastructure you own.

Gotchas to know before you install

Who this is for

Community signal

Rowboat has launched twice this year, and the reception has been a genuine mix. The July 2026 Show HN post — the one this guide draws its Hacker News quotes from — hit 214 points and 92 comments, with praise for the ambition alongside the local-first pushback above. On the same thread, developer dannyobrien asked for something Rowboat doesn’t yet document: multi-person, pair-prompting sessions where two people steer one agent together. Commenter TranquilMarmot’s reply was blunt about the competitive risk every wrapper-shaped startup faces: both OpenAI and Anthropic are “building towards this very quickly,” pointing at Claude’s own Slack integration as evidence the big labs are already moving into shared-session territory.

Earlier reactions ran warmer on raw excitement. Rowboat’s April 2026 Product Hunt launch drew quick support in its replies (“Congrats on the launch team. I have been trying the product, liking it so far,” from one early tester), and a February 2026 wave of attention focused specifically on the knowledge-graph mechanic — before the July relaunch added the full work-surfaces platform on top.

The verdict

The bigger picture

Rowboat sits on the open, local-first side of a split that’s defining AI tooling in 2026: vendor-hosted agent platforms like Cowork on one side, self-hosted, model-agnostic alternatives on the other — the same split our local LLM runtime comparison covers at the model layer. The honest risk, raised on Rowboat’s own Show HN thread, is that the majors build the same shared-memory, multi-surface idea natively and ship it to hundreds of millions of existing users overnight. The honest counter is that “your data as plain Markdown you own” isn’t a feature a hosted platform can copy without giving up the thing that makes it a hosted platform. That tension, not any single feature, is what’s worth watching.

Frequently Asked Questions

Glossary

Sources

• Primary — repo, README, and license: github.com/rowboatlabs/rowboat (Apache-2.0, TypeScript)
• Primary — product site & downloads: rowboatlabs.com
• Primary — official demo videos (RowBoat, YC S24, verified via YouTube oEmbed): “Rowboat Work Surfaces” · “Rowboat – Cowork meets Obsidian”
• Community — Show HN thread (214 points, 92 comments, July 2026): “Rowboat – Open-source, local-first alternative to Claude Desktop”
• Community — verified launch tweet: @segmenta, April 21, 2026
• Community — Reddit threads from a Rowboat team member: r/selfhosted, Feb 2026 · r/LocalLLaMA, Feb 2026
• Canonical MCP.Directory entries referenced: /servers/ollama, /servers/exa-search, /servers/slack, /servers/linear, /servers/github, /servers/elevenlabs
• Related guides: Claude Cowork & Managed Agents · What is MCP · Ollama vs LM Studio vs Jan vs vLLM · Agent Client Protocol vs MCP