rowboat

Rowboat is an open-source platform for constructing and deploying multi-agent AI workflows without writing boilerplate orchestration code. It provides a visual workflow builder where you define individual agents with custom instructions, model choices, and tool access, then wire them together using handoff rules, pipeline steps, and control-flow types — all backed by a typed schema that validates agent configurations at design time.

Each project in Rowboat has a draft workflow and a live workflow, letting teams iterate on agent configurations without disrupting production traffic. Conversations are persisted in MongoDB and streamed in real time via Server-Sent Events, with Redis used for caching and pub/sub. The platform ships with an AI copilot that understands your current workflow and assists with agent design decisions directly inside the editor.

Rowboat supports RAG through Qdrant vector storage with configurable data sources — web scraping via Firecrawl, file uploads via S3, and manual document ingestion. External tool integration is handled through both the Model Context Protocol (MCP) and Composio, giving agents access to hundreds of third-party services without custom connectors. Scheduled and recurring job rules let agents run on cron triggers or respond to external webhook events from Composio.

A Python SDK and REST API make it straightforward to embed Rowboat agent workflows into existing applications, call them from backend services, or integrate them with customer-facing products. Self-hosters deploy the full stack with Docker Compose, bringing their own LLM provider API key and pointed at any OpenAI-compatible endpoint.

What You Get

• Visual multi-agent workflow builder with drag-and-drop agent configuration, handoff rules, and pipeline step ordering
• Draft and live workflow separation so you can iterate on agent configs without affecting production conversations
• RAG data source management backed by Qdrant vector storage, supporting web scraping, S3 file uploads, and manual document ingestion
• MCP tool integration supporting both Streamable HTTP and SSE transports, plus Composio for 200+ pre-built service connectors
• Scheduled and recurring job rules that trigger agent workflows on cron schedules or via external webhook events
• AI copilot inside the workflow editor that understands your agent graph and helps you design better multi-agent systems
• Python SDK and documented REST API for embedding agent workflows in external applications
• Embeddable chat widget for deploying agent-powered interfaces directly into web products

Common Use Cases

• Building a customer support system with specialized routing agents that hand off to domain experts based on query classification
• Creating an internal knowledge assistant with RAG over company documentation, with a pipeline agent that formats answers into consistent templates
• Automating recurring workflows — such as weekly reports or data sync jobs — by scheduling agent runs via cron trigger rules
• Embedding a product-facing AI assistant in a SaaS application using the chat widget and REST API without managing LLM infrastructure
• Prototyping complex agent collaboration patterns in the playground before promoting a workflow to live traffic
• Integrating third-party services like GitHub, Slack, or Linear into agent tool sets via Composio without writing custom API clients

Under The Hood

Architecture Rowboat follows a clean Domain-Driven Design structure with four explicit layers: entities (Zod-validated domain models), application (use cases, policies, repository interfaces, and workers), infrastructure (MongoDB repositories, Redis services, S3 storage), and interface adapters (controllers wired via an Awilix dependency injection container). Each conversation turn flows from a Next.js API route through a typed controller into a use case that enforces authorization and quota policies before delegating to the agents runtime. The workflow definition itself is stored as a validated JSON document that travels alongside each conversation, enabling stateless agent execution while preserving full reproducibility. Agent handoffs between conversation, pipeline, escalation, and post-process agents are managed by a pipeline state manager that tracks step progression and context passing across turns.

Tech Stack The main application is Next.js 15 with React 19 running in a Node.js container, using MongoDB as the primary datastore for projects, conversations, and job state. Redis handles conversation turn caching and pub/sub event delivery for streaming responses. Vector storage for RAG is provided by Qdrant with text embeddings generated via configurable OpenAI-compatible embedding endpoints. The agent runtime is built on the OpenAI Agents SDK with support for provider-agnostic LLM backends through the AI SDK’s OpenAI adapter, allowing any compatible endpoint to be substituted. External tool integration uses the Model Context Protocol SDK supporting both Streamable HTTP and SSE transports, plus Composio’s TypeScript SDK for managed service connectors. TypeScript with Zod schemas enforces type safety across the entire entity and use-case layer, and Tailwind CSS with HeroUI components powers the frontend.

Code Quality The codebase demonstrates solid architectural discipline — the DDD layer separation is consistently maintained with repository interfaces decoupled from MongoDB implementations throughout. Zod schemas provide runtime validation at the entity level with explicit error types in the entities/errors module, and the awilix DI container ensures dependencies are explicitly declared rather than imported directly. Testing coverage is limited to a separate apps/x electron application (using Vitest), with no test files present in the main rowboat application. Error handling in the agents runtime is explicit with typed turn events that distinguish billing errors, quota errors, and agent execution failures. The CI configuration is not visible in the shallow clone, and the rapid release cadence (multiple releases per week) suggests feature velocity is prioritized over coverage infrastructure.

What Makes It Unique Rowboat’s most distinctive technical decision is encoding the entire workflow definition — all agents, their configurations, handoff rules, and tool assignments — as a validated document stored and versioned per conversation, rather than as static server-side configuration. This means every conversation replay is fully deterministic and workflow migrations are explicit. The draft/live workflow separation at the project level, enforced through a typed schema with StrictWorkflowAgent refinements, provides a production-safe iteration model uncommon in open-source agent frameworks. The integrated copilot that reads the live workflow graph and provides contextual design suggestions within the editor is a genuinely novel UX approach for agent builder tooling.

Self-Hosting

Rowboat is released under the Apache License 2.0, a permissive open-source license that allows commercial use, modification, distribution, and private deployment without restriction. There are no copyleft obligations — you can incorporate Rowboat into proprietary systems or sell services built on top of it without releasing your own code. Attribution notices must be preserved, but that is the only substantive requirement for self-hosters.

Running Rowboat yourself requires coordinating several services: a Next.js application server, MongoDB for conversation and project persistence, Redis for caching and pub/sub, and Qdrant for vector storage if you enable RAG. The provided Docker Compose file wires all of these together, making a single-machine deployment straightforward. Operationally you are responsible for backup schedules on MongoDB, Qdrant index persistence, Redis memory sizing, and keeping the Next.js container updated as new releases ship. The project releases frequently — multiple releases per week — so staying current demands attention. There is no built-in database migration tooling beyond manual index management scripts, so schema changes require care.

Rowboat Labs offers a hosted cloud version at rowboatlabs.com with managed infrastructure, Auth0 authentication, and a billing layer that controls model access and usage quotas. Self-hosters bypass all of that entirely, which means you handle your own user authentication setup (Auth0 credentials are still required if you enable auth), your own LLM API key management, and your own usage monitoring. There are no SLAs, managed upgrades, or enterprise support contracts for the open-source deployment — community support is available on Discord, and Rowboat Labs appears to be an early-stage Y Combinator company (S24 batch), so the commercial support offering is still evolving.