rowboat

ser, and parallel coding, where the assistant can help inside the workflow itself rather than only through chat: - Email client: Rowboat has a simple email client that sorts incoming emails into important vs. everything else, and pre-creates drafts for important emails. As you edit and send emails, it takes notes on your style, so future drafts get closer to your voice. - Meeting notes: We built a Granola-style local meeting notetaker. Notes are stored as plain Markdown files on your machine. After a meeting, Rowboat feeds the notes back into the knowledge graph and updates the relevant people, project, and topic notes. - Browser: We added a built-in browser, isolated from your main one, where you can log in only to the accounts you want the assistant to help with. The assistant uses browser-use skills to navigate websites. - Parallel coding: The code-mode inside Rowboat lets you spin multiple instances of Claude Code or Codex and either work with them directly or let Rowboat use your work context to orchestrate them. We built an ACP (Agent Client Protocol) client in Rowboat for this. - Notes: Rowboat has an Obsidian-style local note-taking system. It comes with graph view, bases view, and voice notes. You can also sync Google Docs files and edit them inside Rowboat. You can also build your own work surfaces inside Rowboat (web apps). Each app gets its own UI and a background agent, and can use all of Rowboat's tools, product integrations, and your work memory. For instance: an app to manage GitHub activity, project tracking, or ads campaign management. There are a few community apps at launch you can search and install, and you can publish your own by creating a GitHub repo for it and registering it. Rowboat also indexes your work into a knowledge graph that all of the above surfaces use to have better context. We did a Show HN a few months back on this: https://news.ycombinator.com/item?id=46962641. As an example that ties some of these together: you can create an app inside Rowboat that collects feature requests from your email, meetings, and Slack and ranks them, then uses Claude Code to draft a first version of the top-ranked feature, pulling prior context about it from your knowledge graph. Rowboat is local-first: data is stored as plain Markdown files you can read, edit, or delete anytime. It is Apache-2.0 and works with any LLM, including local models through Ollama or LM Studio. We’d love to hear your thoughts, and contributions are welcome!

lly as linked and editable Markdown files (Obsidian-style), organized around people, projects, and topics. As new conversations happen (including voice memos), related notes update automatically. If a deadline changes in a standup, it links back to the original commitment and updates it. (2) A local assistant: On top of that graph, Rowboat includes an agent with local shell access and MCP support, so it can use your existing context to actually do work on your machine. It can act on demand or run scheduled background tasks. Example: “Prep me for my meeting with John and create a short voice brief.” It pulls relevant context from your graph and can generate an audio note via an MCP tool like ElevenLabs. Why not just search transcripts? Passing gigabytes of email, docs, and calls directly to an AI agent is slow and lossy. And search only answers the questions you think to ask. A system that accumulates context over time can track decisions, commitments, and relationships across conversations, and surface patterns you didn't know to look for. Rowboat is Apache-2.0 licensed, works with any LLM (including local ones), and stores all data locally as Markdown you can read, edit, or delete at any time. Our previous startup was acquired by Coinbase, where part of my work involved graph neural networks. We're excited to be working with graph-based systems again. Work memory feels like the missing layer for agents. We’d love to hear your thoughts and welcome contributions!

accumulates context over time can track decisions, commitments, and relationships across conversations, surfacing patterns you didn’t know to look for. Once this context exists, it becomes knowledge that Rowboat can work with. Because it runs on your machine, it can work directly with local files and run shell commands or scripts, including tools like ffmpeg when needed. The link in the title opens an interactive example graph showing how context accumulates across emails and meetings. We used a founder example because it naturally includes projects, people, and long-running conversations, but the structure applies to any role. Examples of what you can do with Rowboat: draft emails from accumulated context, prep for meetings by assembling past decisions and enriching them with external research (for example via Exa MCP), organize files and project artifacts on your machine as work evolves, or turn notes into voice briefings via MCP servers like ElevenLabs. We’re opinionated about noise. We prioritize recurring contacts, active projects, and ongoing work, and ignore one-off emails and notifications. The goal is long-lived knowledge that compounds over time. All data is stored locally as plain Markdown. You can use local models via Ollama or LM Studio, or a hosted model. Apache-2.0 licensed. GitHub: https://github.com/rowboatlabs/rowboat Curious how this fits into your current workflow for everyday work.

produces a NotebookLM-style podcast every day from recent AI-agent papers on arXiv. Or you can connect it to Google Calendar and Exa Search to research meeting attendees and generate briefs before each event. You can try these with: `npx @rowboatlabs/rowboatx` We combined three simple ideas: 1. File system as state: Each agent’s instruction, memory, logs, and data are just files on disk, grepable, diffable, and local. For instance, you can just run: grep -rl '"agent":"<agent-name>"' ~/.rowboat/runs to list every run for a particular workflow. 2. The supervisor agent: A Claude Code style agent that can create and run background agents. It predominantly uses Unix commands to monitor, update, and schedule agents. LLMs handle Unix tools better than backend APIs [1][2], so we leaned into that. It can also probe any MCP server and attach the tools to the agents. 3. Human-in-the-loop: Each background agent can emit a human_request message when needed (e.g. drafting a tricky email or installing a tool) that pauses execution and waits for input before continuing. The supervisor coordinates this. I started my career over a decade ago building spam detection models at Twitter, spending a lot of my time in the terminal with Unix commands for data analysis [0] and Vowpal Wabbit for modeling. When Claude Code came along, it felt familiar and amazing to work with. But trying to use it beyond code always felt a bit forced. We built RowboatX to bring that same workflow to everyday tasks. It is Apache-2.0 licensed and easily extendable. While there are many agent builders, running on the user's terminal enables unique use cases like computer and browser automation that cloud-based tools can't match. This power requires careful safety design. We implemented command-level allow/deny lists, with containerization coming next. We’ve tried to design for safety from day one, but we’d love to hear the community’s perspective on what additional safeguards or approaches you’d consider important here. We’re excited to share RowboatX with everyone here. We’d love to hear your thoughts and welcome contributions! — [0] https://web.stanford.edu/class/cs124/kwc-unix-for-poets.pdf [1] https://arxiv.org/pdf/2405.06807 [2] https://arxiv.org/pdf/2501.10132

ibility: flowchart adds edges; handoffs add a function COI: We built Rowboat around handoffs. The code is open source: https://github.com/rowboatlabs/rowboat

ity: flowchart adds edges; handoffs add a function COI: We built Rowboat around handoffs using OpenAI’s Agents SDK. The code is open source: https://github.com/rowboatlabs/rowboat

th a cloud offering. We’ve added built-in tool integrations for 100s of tools like Gmail, Github and Slack, RAG with documents and URLs, and triggers to invoke your assistant based on external events. Our cloud version includes all the features of the open-source IDE, but runs instantly with no setup or API keys. For launch, we're offering $10 free usage with Gemini models so you can start building right away for free without adding any card details. Paid plans start at $20/month and give you access to additional models (OpenAI, Anthropic, Gemini, with more coming) and higher usage limits. There’s a growing view that some tasks are better handled by single agents (https://news.ycombinator.com/item?id=45096962), while others benefit from multi-agent systems for higher accuracy ( https://www.anthropic.com/engineering/multi-agent-research-s...). The difference often comes down to scope: a focused task like coding suits a single agent, but juggling multiple domains such as email, Slack, and LinkedIn is better split across agents. Multi-agent systems also help avoid context pollution, since LLMs lose focus when asked to handle unrelated tasks. In addition, cleanly dividing responsibilities makes each agent easier to test, debug, and improve. However, splitting work into multiple agents and getting their prompts right is challenging. OpenAI and others have published patterns that work well for different scenarios (https://cdn.openai.com/business-guides-and-resources/a-pract...). We’ve added agent abstractions, built on top of OpenAI’s Agents SDK, to support these patterns. These include user-facing agents that can decide to hand off to another agent when needed; task agents that perform internal tasks; and pipelines that deterministically call a sequence of agents. Rowboat’s copilot (‘Skipper’) is aware of these patterns and has been seeded with tested patterns, such as a manager‑worker setup for a customer support bot, a pipeline for automated document summarization, and multi‑agent workflows for combining web search with RAG. It can: - Build multi-agent systems from a high-level request and decide how work must be delegated across agents - Edit agent instructions to make correct tool calls using Composio tools or any connected MCP server - Observe your playground chat and improve agents based on your tests We see agentic systems as a spectrum. On one end are deterministic workflows with a few LLM calls. On the other end are fully agentic systems where the LLM makes all control flow decisions - we focus on this end of the spectrum, while still allowing deterministic control where necessary for real-world assistant use cases. We intentionally avoided flowchart-style editors (like n8n) because they become unwieldy when building and maintaining highly agentic systems. We look forward to hearing your thoughts!

erent agents handle specialized tasks: one agent finds the best flights, another optimizes hotel selections, and a third organizes the itinerary. This modular approach makes the system easier to manage, debug, and improve over time. OpenAI’s Agents SDK provides a neat Python library to support this, but building reliable agentic systems requires constant iterations and tweaking - e.g. updating agent instructions (which can quickly get as complex as actual code), connecting tools, and testing the system and incorporating feedback. Rowboat is an AI IDE to do all this. Rowboat is to AI agents what Cursor is to code. We’ve taken a code-like approach to agent instructions (prompts). There are special keywords to directly reference other agents, tools or prompts - which are highlighted in the UI. The copilot is the best way to create and edit these instructions - each change comes with a code-style diff. You can give agents access to tools by integrating any MCP server or connecting your own functions through a webhook. You can instruct the agents on when to use specific tools via ‘@mentions’ in the agent instruction. To enable quick testing, we added a way to mock tool responses using LLM calls. Rowboat playground lets you test and debug the assistants as you build them. You can see agent transfers, tool invocations and tool responses in real-time. The copilot has the context of the chat, and can improve the agent instructions based on feedback. For example, you could say ‘The agent shouldn’t have done x here. Fix this’ and the copilot can go and make this fix. You can integrate agentic systems built in Rowboat into your application via the HTTP API or the Python SDK (‘pip install rowboat’). For example, you can build user-facing chatbots, enterprise workflows and employee assistants using Rowboat. We’ve been working with LLMs since GPT-1 launched in 2018. Most recently, we built Coinbase’s support chatbot after our last AI startup was acquired by them. Rowboat is Apache 2.0 licensed, giving you full freedom to self-host, modify, or extend it however you like. We’re excited to share Rowboat with everyone here. We’d love to hear your thoughts!