Introduction

Managing a fragmented digital workspace is a constant struggle for modern knowledge workers. Information is scattered across emails, Slack threads, meeting transcripts, and various documents, making it nearly impossible to maintain a cohesive view of project history and decisions. Rowboat, an open-source AI coworker with over 16k GitHub stars, solves this by indexing your work life into a living, local knowledge graph that an AI agent can act upon. Instead of relying on generic chat interfaces, Rowboat provides a dedicated work environment where your AI assistant has a persistent memory of your actual work context.

What Is Rowboat?

Rowboat is a desktop AI coworker that turns your work artifacts—emails, meeting notes, and conversations—into a local, linked knowledge graph. Built with TypeScript and licensed under the Apache-2.0 license, it allows users to maintain a “second brain” that is entirely local-first, ensuring that sensitive work data remains on the user’s machine. The tool operates as a comprehensive work surface, integrating an email client, a meeting note-taker, and a browser, all powered by an agent that can traverse the knowledge graph to perform complex tasks.

The project is maintained by RowBoat Labs and is designed to be a local-first alternative to tools like Claude Desktop, providing a more integrated experience where the AI doesn’t just chat, but actually manages the context of your work life.

Why Rowboat Matters

Most AI assistants suffer from “context window fatigue,” where they forget decisions made weeks ago or require the user to manually upload documents to every new session. Rowboat eliminates this by creating a persistent, human-readable memory store. By treating memory as a folder of Markdown files with backlinks (similar to Obsidian), Rowboat ensures that the AI’s memory is not a black box, but a transparent, editable resource that the user owns.

The local-first architecture is critical for professionals in regulated industries or those who are privacy-conscious. Because the knowledge graph is stored as plain text on disk, it avoids vendor lock-in and ensures that the user’s most sensitive organizational context remains private. This shift from a stateless chat interface to a stateful AI coworker transforms the AI from a simple tool into a teammate that understands the nuance of your projects, people, and decisions.

Key Features

• Living Knowledge Graph: Rowboat automatically indexes emails, meetings, and Slack conversations into a linked network of nodes (People, Projects, Decisions, Tasks) stored as local Markdown files with Obsidian-style backlinks.
• Integrated Work Surfaces: The app includes a built-in email client that sorts important messages and drafts replies based on work context, a local meeting note-taker that live-transcribes audio and updates the graph, and an isolated browser for AI-assisted web tasks.
• Local-First Privacy: All data, including the knowledge graph, is stored locally on your machine, allowing you to use local LLMs via Ollama or LM Studio, or connect to cloud providers while keeping the memory store private.
• MCP Tool Integration: Rowboat supports the Model Context Protocol (MCP), enabling it to connect to hundreds of external tools, databases, and CRMs through standardized interfaces.
• Multi-Agent Orchestration: Users can build and orchestrate multi-agent systems where different agents handle specific roles (e.g., a manager agent and a worker agent) to reduce context pollution and improve task accuracy.
• Event-Driven Automation: The system supports background agents triggered by specific events, such as a new incoming email, or schedules (cron-like jobs) to perform daily reporting or triage.
• Parallel Coding Mode: A dedicated code-mode allows users to spin up multiple instances of Claude Code or Codex, orchestrating them using the project’s work context.
• Human-Inspectable Memory: Because the memory is just Markdown, users can open the vault in Obsidian or any text editor to manually correct the AI’s beliefs or add high-priority facts.

How Rowboat Compares

Rowboat distinguishes itself by moving away from the “chat-centric” model of AI. While Claude Desktop is an excellent interface for interacting with an LLM, it remains a stateless tool. Rowboat, however, is a stateful environment. It doesn’t just provide an answer; it manages the context of your work life. By integrating the tools where the work actually happens—email and meeting notes—Rowboat reduces the friction of context switching.

Compared to Notion AI, Rowboat offers a critical advantage in terms of ownership. Notion’s agents run within their proprietary ecosystem, creating vendor lock-in. Rowboat’s use of plain Markdown files ensures that your knowledge graph is portable and inspectable. For power users who already use Obsidian or Logseq, Rowboat acts as an automated engine that populates their second brain without requiring manual entry.

Getting Started: Installation

Rowboat is distributed as a desktop application for Mac, Windows, and Linux. You can install it using the provided binaries or by cloning the repository for a manual build.

Binary Installation

The fastest way to get started is to download the latest release from the GitHub releases page.

Download latest for Mac/Windows/Linux from: https://github.com/rowboatlabs/rowboat/releases/latest

Manual Installation (Git Clone)

For developers who wish to build from source, you can clone the repository and install dependencies.

git clone https://github.com/rowboatlabs/rowboat.git
npm install
npm run dev

Prerequisites

To use Rowboat effectively, you will need an API key from an LLM provider (e.g., OpenAI, Anthropic) or a local LLM runner like Ollama. If you are using Google services, you will need to follow the Google setup guide to create an OAuth client ID and secret.

How to Use Rowboat

Once installed, the first step is to connect your work sources. Navigate to the settings and connect your Gmail, Calendar, and Slack accounts. Rowboat will begin indexing these sources to build your initial knowledge graph. As it processes your data, it creates Markdown files for every person, project, and key decision mentioned in your communications.

You can then interact with the AI coworker using the integrated chat interface. For example, you can ask, “Who is the main contact for Project X?” or “What were the key decisions made during the last meeting with Alex?” The agent will traverse the knowledge graph, pull the relevant Markdown notes, and provide a concise answer grounded in your actual work history.

If you need to perform a complex task, you can describe a workflow. For instance, you can tell Rowboat, “Build me a deck about our next quarter roadmap.” The agent will pull priorities from the knowledge graph, load a presentation skill, and export a PDF. This moves the AI from a simple query tool to an active participant in your workflow.

Code Examples

Rowboat provides an HTTP API and a Python SDK for extending its capabilities. You can integrate Rowboat agents into your own applications or automate tasks via script.

Using the Python SDK

The following example shows how to create a stateful chat session with a Rowboat agent using the Python SDK.

pip install rowboat

import rowboat

client = rowboat.Client(api_key="YOUR_API_KEY")
chat = client.create_chat_session(project_id="PROJECT_ID")
response = chat.send_prompt("Summarize the latest project updates from the knowledge graph.")
print(response.text)

Integrating via HTTP API

Rowboat’s API is exposed at http://localhost:3000/api/v1/. You can send a prompt to a specific project agent using a curl command.

curl -X POST http://localhost:3000/api/v1/chat \n-H "Content-Type: application/json" \n-d '{"project_id": "PROJECT_ID", "prompt": "What are the open questions for the Q3 roadmap?"}'

Advanced Configuration

Rowboat allows for deep customization of its memory and tool integration. To enable specific AI capabilities, you must add API keys to the configuration files located in ~/.rowboat/config/.

• Voice Input/Output: Add a Deepgram API key in deepgram.json and an ElevenLabs API key in elevenlabs.json for voice-enabled interactions.
• Web Search: To enable the AI to perform research, add an Exa API key in exa-search.json.
• External Tools: To enable external tool access via Composio, add an API key in composio.json.

Since the knowledge graph is just Markdown, you can also configure the laout of your vault by manually editing the .md files or using a tool like Obsidian to manage the backlinks and structure of the AI’s memory.

Real-World Use Cases

Rowboat excels in scenarios where context is the primary bottleneck for productivity. Here are a few concrete examples:

• Meeting Preparation: A project manager can ask Rowboat to “Prep me for my meeting with Alex.” The agent will pull past decisions, open questions, and relevant threads from the knowledge graph to create a crisp brief, which can even be delivered as a voice note for commuting.
• Email Triage and Drafting: An executive can use the built-in email client to identify important emails and have Rowboat draft personalized replies based on the context of previous conversations and the user’s specific writing style.
• Project Decision Tracking: A lead developer can use Rowboat to maintain a living record of why a certain technical decision was made. By linking meeting notes to project nodes, Rowboat ensures that the architectural decisions are not lost in a sea of Slack messages.
• Multi-Agent Research: A researcher can build a multi-agent system where one agent scrapes a webpage via the isolated browser, another classifies the information, and another synthesizes it into a project note in the knowledge graph.

Contributing to Rowboat

Rowboat is an open-source project licensed under Apache-2.0, and contributions are welcome. You can contribute by reporting bugs via GitHub Issues or submitting pull requests for new features or tool integrations. The project encourages the creation of new “skills” or MCP servers to expand the agent’s capabilities.

If you are a developer, you can start by looking for “good first issues” on the GitHub repository to help improve the core application or add support for more work surfaces.

Community and Support

Rowboat has a growing community of AI enthusiasts and privacy-conscious developers. Official support channels include the GitHub Discussions tab and GitHub Issues for bug reports. For real-time collaboration and community discussion, you can join the Rowboat Discord server.

The project also provides a detailed documentation site at docs.rowboatlabs.com, which covers everything from basic setup to advanced multi-agent orchestration.

Conclusion

Rowboat represents a fundamental shift in how we interact with AI in the workplace. By moving from a stateless chat interface to a stateful AI coworker with a local, human-readable memory, it solves the core problem of fragmented work context. For anyone who manages complex projects with high volumes of communication, Rowboat is an indispensable tool for ensuring that no decision or detail is lost.

While the project is still evolving and requires some initial configuration (such as OAuth setup for Google services), the trade-off is total ownership of your work memory. If you are looking for an AI assistant that actually remembers your work life and operates on your own infrastructure, Rowboat is the right choice.

Star the repo, try the quickstart, and join the community to help shape the future of the open-source AI coworker.

Resources

• Rowboat GitHub Repository
• Official Rowboat Documentation
• Rowboat Labs Website
• Rowboat Discord Community