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

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 initializes the application window, while apps/x/apps/renderer/src/main.tsx renders the React-based UI. Communication between processes flows through 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. 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 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.

# 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) provides a thin wrapper around the HTTP API. This allows Python applications to invoke agents and list tools using familiar method calls.

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 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 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 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.

Tool Execution Flow

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

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. These agents can perform recurring tasks such as daily briefings or project updates without user intervention.

# 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 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, 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), Next.js web dashboard (apps/rowboat/app/page.tsx), CLI (apps/cli/bin/app.js), and Python SDK (apps/python-sdk/).
• MCP integration (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) 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).

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, 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), it also offers a Next.js web dashboard (apps/rowboat/app/page.tsx), a command-line interface (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) 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) to avoid re-processing unchanged files, ensuring efficient updates while maintaining an editable, portable knowledge vault.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}