# Rowboat Features: A Complete Guide to the Local-First AI Coworker

> Explore Rowboat features: the open-source local-first AI coworker. Transform emails meetings and files into a searchable knowledge graph via desktop app web dashboard CLI or Python SDK.

- Repository: [RowBoat Labs/rowboat](https://github.com/rowboatlabs/rowboat)
- Tags: deep-dive
- Published: 2026-02-16

---

**Rowboat is an open-source, local-first AI coworker that transforms emails, meetings, and files into a searchable knowledge graph while providing multiple interfaces including an Electron desktop app, web dashboard, CLI, and Python SDK.**

The `rowboatlabs/rowboat` repository delivers a comprehensive platform for building personal AI workflows. Unlike cloud-dependent alternatives, Rowboat stores all data locally as plain Markdown in an Obsidian-compatible vault, ensuring complete privacy and portability while integrating with external services through the Model Context Protocol (MCP).

## Multi-Platform Architecture

Rowboat provides four distinct interfaces to accommodate different workflows, all sharing the same core logic located in `apps/x/packages/core/src/`.

### Electron Desktop Client

The primary interface is a native desktop application built with Electron. The main process entry point at [`apps/x/apps/main/src/main.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/main/src/main.ts) initializes the application window, while [`apps/x/apps/renderer/src/main.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/renderer/src/main.tsx) renders the React-based UI. Communication between processes flows through [`apps/x/apps/preload/src/preload.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/preload/src/preload.ts), which uses Electron's `contextBridge` to expose safe functions like `executeMcpTool` and `workspace-readFile` to the renderer.

### Web Dashboard

For browser-based access, Rowboat includes a Next.js application located in [`apps/rowboat/app/page.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/rowboat/app/page.tsx). This provides the same functionality as the desktop client without requiring local installation, making it suitable for team environments or quick access scenarios.

### Command-Line Interface

The CLI at [`apps/cli/bin/app.js`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/bin/app.js) enables automation and scripting. Users can run agents directly from the terminal, import or export workflows, list examples, and configure models without launching the graphical interface.

```bash

# Start the default "copilot" agent

rowboatx

# Run a specific agent with input

rowboatx --agent=search_agent --input="Find the latest quarterly earnings for Acme Corp"

```

### Python SDK

For programmatic integration, the Python SDK (documented in [`apps/python-sdk/README.md`](https://github.com/rowboatlabs/rowboat/blob/main/apps/python-sdk/README.md)) provides a thin wrapper around the HTTP API. This allows Python applications to invoke agents and list tools using familiar method calls.

```python
from rowboat import RowboatClient

client = RowboatClient(api_key="YOUR_OPENAI_KEY")
response = client.run_agent(
    agent="copilot",
    input="Draft a 2‑page project brief for the upcoming Q3 redesign"
)

print(response.content)

```

## Knowledge Graph Engine

At the heart of Rowboat is a local-first knowledge graph that processes diverse data sources into interconnected Markdown notes.

### Local Data Storage

All data resides in `~/.rowboat/knowledge/` as plain Markdown files with backlinks, making the vault fully compatible with Obsidian. This architecture ensures users can inspect, back up, or delete data at any time without vendor lock-in.

### Graph Construction Pipeline

The knowledge builder at [`apps/x/packages/core/src/knowledge/build_graph.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/knowledge/build_graph.ts) processes inputs from Gmail, Fireflies meeting transcripts, and other sources. It uses a hybrid **mtime+hash** change-detection strategy implemented in [`apps/x/packages/core/src/knowledge/graph_state.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/knowledge/graph_state.ts) to avoid re-processing unchanged files, significantly improving performance on subsequent runs.

## MCP Integration for External Tools

Rowboat extends its capabilities through the Model Context Protocol (MCP), allowing integration with external services without modifying core code.

### MCP Client Implementation

The MCP client at [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts) handles discovery, configuration, and execution of tools from any MCP server. Server configurations are stored in `~/.rowboat/config/mcp.json`, managed through built-in tools defined in [`apps/x/packages/core/src/application/builtin-tools.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/builtin-tools.ts).

### Tool Execution Flow

Agents can discover and execute MCP tools dynamically. For example, to add a web search capability:

```bash
rowboatx --agent=copilot --input="Add MCP server named firecrawl with URL https://api.firecrawl.dev"

```

Once configured, agents can invoke the tool using standard JSON-RPC requests through the MCP layer.

## Agent System and Workflow

Rowboat uses a markdown-centric approach to agent definition, making AI workflows transparent and version-controllable.

### Markdown-Based Agent Definitions

Each agent is defined as a Markdown file with YAML front-matter declaring its purpose, available tools, model preferences, and system prompts. These files reside in `apps/x/packages/core/src/application/assistant/agents/` and are read at runtime, allowing users to create, edit, and chain agents without restarting the application.

### Background Agents

Autonomous workers run periodically using the scheduler implemented in [`apps/x/packages/core/src/application/assistant/skills/background-agents/skill.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/background-agents/skill.ts). These agents can perform recurring tasks such as daily briefings or project updates without user intervention.

```bash

# List available background agents

rowboatx --agent=background --input="list"

# Trigger the daily briefing agent

rowboatx --agent=dailyBriefing

```

## Multi-Model Support

Rowboat abstracts model providers through a unified configuration system. The model configuration handler at [`apps/x/packages/core/src/model/modelConfig.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/model/modelConfig.ts) supports OpenAI, Anthropic, Google, Ollama, OpenRouter, LiteLLM, and custom providers via `~/.rowboat/config/models.json`. This flexibility allows users to switch between local and cloud models based on privacy requirements or cost constraints.

## Voice and Data Ingestion

For audio input, Rowboat integrates with Deepgram through [`apps/x/packages/core/src/voice/deepgram-client.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/voice/deepgram-client.ts), converting voice memos into structured notes automatically. Combined with the knowledge graph builder, this creates a seamless pipeline from spoken ideas to searchable, interlinked knowledge.

## Summary

- **Rowboat** is a local-first AI coworker that stores all data as plain Markdown in `~/.rowboat/knowledge/`, ensuring complete privacy and Obsidian compatibility.
- The platform offers **multiple interfaces**: an Electron desktop app ([`apps/x/apps/main/src/main.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/main/src/main.ts)), Next.js web dashboard ([`apps/rowboat/app/page.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/rowboat/app/page.tsx)), CLI ([`apps/cli/bin/app.js`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/bin/app.js)), and Python SDK (`apps/python-sdk/`).
- **MCP integration** ([`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts)) enables dynamic discovery and execution of external tools without core code changes.
- **Knowledge graph construction** ([`apps/x/packages/core/src/knowledge/build_graph.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/knowledge/build_graph.ts)) processes emails and meetings into an interconnected Markdown vault using mtime+hash change detection.
- **Agent workflows** are defined as Markdown files with YAML front-matter, supporting both interactive and **background agents** ([`apps/x/packages/core/src/application/assistant/skills/background-agents/skill.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/application/assistant/skills/background-agents/skill.ts)).

## Frequently Asked Questions

### What makes Rowboat different from other AI assistants?

Rowboat operates on a **local-first** architecture where all data remains as plain Markdown files in `~/.rowboat/knowledge/`. Unlike cloud-based assistants, Rowboat provides complete data ownership, Obsidian compatibility for note-taking, and offline functionality while still integrating with external services through the Model Context Protocol.

### How does Rowboat handle external tool integration?

Rowboat implements the **Model Context Protocol (MCP)** through [`apps/x/packages/core/src/mcp/mcp.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/mcp/mcp.ts), allowing it to discover, configure, and execute tools from any MCP server. Users can add servers via the CLI or built-in tools, storing configurations in `~/.rowboat/config/mcp.json`. This architecture supports web search, database queries, voice synthesis, and other capabilities without modifying core code.

### Can I use Rowboat without the desktop application?

Yes. While Rowboat provides a full-featured **Electron desktop client** ([`apps/x/apps/main/src/main.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/apps/main/src/main.ts)), it also offers a **Next.js web dashboard** ([`apps/rowboat/app/page.tsx`](https://github.com/rowboatlabs/rowboat/blob/main/apps/rowboat/app/page.tsx)), a **command-line interface** ([`apps/cli/bin/app.js`](https://github.com/rowboatlabs/rowboat/blob/main/apps/cli/bin/app.js)), and a **Python SDK** (`apps/python-sdk/`). These alternatives provide flexibility for server deployments, automation scripts, and programmatic integrations.

### How does Rowboat process and store knowledge?

Rowboat's **knowledge graph engine** ([`apps/x/packages/core/src/knowledge/build_graph.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/knowledge/build_graph.ts)) ingests data from sources like Gmail and Fireflies meetings, converting them into **Markdown notes with backlinks** stored in `~/.rowboat/knowledge/`. The system uses a hybrid **mtime+hash** change-detection strategy ([`apps/x/packages/core/src/knowledge/graph_state.ts`](https://github.com/rowboatlabs/rowboat/blob/main/apps/x/packages/core/src/knowledge/graph_state.ts)) to avoid re-processing unchanged files, ensuring efficient updates while maintaining an editable, portable knowledge vault.