
What Is OpenDots? The Open-Source AI Coworker Platform Explained
Discover OpenDots by CopilotKit: an open-source, self-hosted template for persistent AI coworkers. Learn its architecture, Spaces, Dot Computers, and setup.
What Is OpenDots? The Open-Source AI Coworker Platform Explained
When OpenAI revealed its vision for autonomous “Dots”—persistent, specialized AI coworkers capable of independent research, computer interaction, and workspace execution—the developer ecosystem faced an immediate dilemma: embrace another proprietary cloud walled garden or build fragmented internal tooling from scratch. In October 2026, the team at CopilotKit answered that challenge by launching OpenDots (CopilotKit/OpenDots), an MIT-licensed, open-source template engineered for self-hosted, persistent AI coworkers.
Rather than offering another lightweight prompt wrapper or a generic chatbot clone, OpenDots establishes a modular workspace architecture. Each autonomous agent—referred to as a Dot—is treated as an independent team member equipped with its own persona, security boundaries, persistent memory, and dedicated containerized computer environment.

However, separating open-source enthusiasm from engineering reality requires precision: OpenDots is an open-source starter template in active Alpha development, not a turnkey consumer SaaS product. To deploy it effectively, engineering teams must configure their own infrastructure, model endpoints, and container runtimes.
In this comprehensive architectural breakdown, we explore how OpenDots works under the hood, analyze its core components—Spaces, Pages, and Dot Computers—examine its human-in-the-loop security protocols, compare it directly to OpenAI’s hosted alternative, and provide a verified deployment guide for engineering teams.
What Is OpenDots? Core Architecture and Philosophy
At its architectural foundation, OpenDots is a full-stack developer template designed to bridge the gap between static LLM chats and autonomous digital coworkers. Built on top of CopilotKit, the AG-UI (Agent-User Interaction) protocol, and container supervision frameworks, OpenDots operates on three primary engineering tenets:
- Persistent Identity and Specialization: Agents are not ephemeral chat windows that reset when the tab closes. Each Dot maintains a persistent persona, distinct system instructions, dedicated database records, and isolated tool authorizations.
- Document-Centric Outputs: Autonomous work should not disappear into an endless chat scrollback. When a Dot completes a research sprint or drafts a specification, its work lands as structured, editable pages within shared workspaces called Spaces.
- Isolated Digital Computers: Rather than executing untrusted commands on the host server, each Dot can be provisioned with its own sandboxed Docker container containing a headless browser, isolated filesystem, and controlled terminal session.
flowchart TD
subgraph ClientSurfaces["Client Interaction Surfaces"]
WebUI["Web Workspace (React / Vite)"]
VoiceCalls["Real-Time Voice Calls (WebRTC)"]
SlackConn["Slack Workspaces (Channels SDK)"]
end
subgraph CoreBackend["OpenDots Core Server (Node.js 24)"]
APIGateway["Fastify / Express API Gateway (:4310)"]
SQLiteDB[("SQLite Storage (Pages, Spaces, Metadata)")]
HITLGate["Human-in-the-Loop Review Engine"]
end
subgraph IntelligenceLayer["CopilotKit Intelligence Layer"]
ThreadsMgr["Conversation & Thread Manager"]
ModelAdapter["OpenAI-Compatible Model Gateway"]
LLMInference["LLM Provider (OpenAI / Claude / Local vLLM)"]
end
subgraph ExecutionPlane["Isolated Execution Plane"]
OpenBotSup["OpenBot Docker Supervisor (:4312)"]
DotSandbox["Sandboxed Dot Computer (Browser / Shell / Files)"]
MCPServers["Remote MCP Servers (Streamable HTTP)"]
end
WebUI --> APIGateway
VoiceCalls --> APIGateway
SlackConn --> APIGateway
APIGateway --> SQLiteDB
APIGateway --> HITLGate
APIGateway --> ThreadsMgr
ThreadsMgr --> ModelAdapter
ModelAdapter --> LLMInference
HITLGate --"Approved Tool Execution"--> OpenBotSup
HITLGate --"Approved MCP Action"--> MCPServers
OpenBotSup --> DotSandbox
By decoupling the user interface, conversation persistence, and computational execution plane, OpenDots gives developers complete sovereignty over their data, their model inference routes, and their operational guardrails.
Core Primitives: Specialist Dots, Spaces, and Living Pages
Understanding OpenDots requires dissecting the three structural primitives that organize both the user experience and the underlying data schema.
1. Specialist Dots
Instead of interacting with a single, monolithic AI assistant expected to answer everything from coding questions to marketing copy, OpenDots encourages teams to deploy Specialist Dots. Each specialist is defined in the workspace database with:
- Identity: Unique identifier, display name, and avatar.
- System Directives: Role-specific system prompts that dictate scope, tone, and operational methodologies.
- Space Access Lists: Explicit permissions detailing which collaborative Spaces the Dot can read from or write to.
- Tool Grants: Granular permissions governing access to the browser, shell execution, filesystem read/writes, and remote MCP connections.
For example, an engineering team might configure “Scout” as a competitive research specialist equipped with read-only browser tools and restricted write permissions limited to the Market Research Space, while configuring “Devon” as an internal documentation reviewer with full shell execution inside a private development sandbox.
2. Spaces: Collaborative Project Domains
A Space is a logical container for organizing domain-specific knowledge and ongoing initiatives. Rather than dumping all conversations into a flat chronological list, Spaces function similarly to Notion workspaces or team channels.
Within a Space, team members and authorized Dots collaborate around shared goals. Dots assigned to a Space automatically inherit context regarding the documents housed inside it, and each Dot possesses a designated default Space where its finalized outputs are cataloged.
3. Living Pages: Where Agent Work Actually Lands
One of the most persistent frustrations with generative AI assistants is the “chat graveyard” problem: high-value research reports, technical designs, and executive summaries remain trapped inside transient chat logs.
OpenDots resolves this by routing autonomous agent deliverables directly into Pages:
- Rich Visual Document Editor: Pages are opened in a distraction-free visual editor supporting slash commands (
/header,/list,/callout), rich typography, undo/redo stacks, and bidirectional Markdown source switching. - Local SQLite Persistence: Pages reside directly in the application’s local SQLite database (
DATABASE_PATH). Unlike cloud-hosted tools where documents live on vendor servers, OpenDots maintains local data ownership. - CopilotKit Threads Integration: Every page maintains its own contextual conversation thread. You can open a launch brief drafted by a Dot, highlight a paragraph, and query the specialist directly within the document canvas without polluting your main agent timeline.
- Optimistic Autosave with Revision Guards: The visual editor features real-time autosave reporting. If a network blip occurs, drafts remain cached locally. Furthermore, server-side revision collision checks prevent stale tabs from overwriting newer updates made by other users or background agents.
Dot Computers: Containerized Sandboxes Powered by OpenBot
Most traditional agent frameworks allow language models to execute code by running shell commands directly on the host machine or by sending arbitrary commands through an insecure local subprocess. In enterprise environments, this approach presents catastrophic security vulnerabilities, including accidental data deletion, reverse shells, and malicious prompt injections.
OpenDots takes an enterprise-first security stance by provisioning each specialist with a dedicated Dot Computer, powered by OpenBot’s container supervisor architecture.
| Security Layer | Traditional Local Agent Scripts | OpenDots Dot Computers |
|---|---|---|
| Execution Boundary | Host OS shell / local Python runtime | Isolated Docker container per Dot |
| Filesystem Access | Unrestricted access to host user directories | Dedicated Docker volume mount per agent |
| Browser Environment | Shared host browser or temporary headless tab | Dedicated, persistent Chromium browser profile |
| Credential Management | Plaintext API keys passed in prompts | Master tokens derived into agent-scoped secrets |
| Host Fallback Policy | Runs on host if remote setup fails | Strict Zero Fallback: Fails safely if container is offline |
| Human Takeover | None (terminal script must be killed) | Real-time interactive browser and terminal takeover |
Sandboxed Container Isolation
When a Dot’s computer is started via compose.computers.yml, the OpenBot supervisor spins up an isolated Docker container tied to that specific Dot’s unique identifier. The container mounts dedicated persistent volumes:
- Workspace Storage: A sandboxed
/workspacefilesystem where the agent can clone repositories, generate build artifacts, and write log files. These files persist across container restarts but remain completely isolated from other Dots and the host operating system. - Browser Profiles: The container runs an isolated Chromium instance. Logins, session states, and browser cache persist across agent sessions, enabling multi-step web research without recurring authentication roadblocks.
Granular Capability Toggles
Every capability within a Dot Computer is disabled by default and requires explicit administrative enablement inside the Edit Specialist dashboard:
- Browser Access: Allows the agent to navigate URLs, click interactive elements, and capture full-page DOM states.
- Workspace File Access: Grants the agent permission to create, inspect, and modify files within its sandboxed volume.
- Shell Access: Authorizes bash execution within the container. OpenDots documentation explicitly mandates that shell access should remain disabled unless an agent specifically requires command-line compilation or script execution.
Interactive Human Takeover
When an agent is actively browsing documentation or running a build script, developers do not have to guess what is happening behind the scenes. Built-in CopilotKit tool renderers display the live browser viewport and streaming terminal output directly within the chat timeline.
If an agent gets stuck on a complex CAPTCHA, encountering an unexpected authentication challenge, or looping on a build failure, the user can initiate Human Takeover. Clicking into the live container view allows the human operator to control the mouse, complete the login manually, or execute diagnostic commands, after which the autonomous agent resumes execution seamlessly.
Human-in-the-Loop Governance: Review Gates & MCP Security
Autonomous AI coworkers are only viable in production if organizations can establish absolute trust in their output. OpenDots enforces two distinct Human-in-the-Loop (HITL) approval barriers: document review gates and state-modifying tool approvals.
flowchart LR
subgraph AgentAction["Agent Action Request"]
DraftPage["Draft Page Generated"]
ToolCall["Tool / MCP Execution"]
end
subgraph InspectionGate["CopilotKit Review Card"]
InspectDraft{"Inspect Draft / Arguments"}
ReadOnlyCheck{"Is Tool Read-Only?"}
end
subgraph Decision["Human Authorization"]
AutoExecute["Autonomous Execution"]
ApprovalCard["Inline 'Approve & Run' Card"]
RejectAction["Decline / Revise Request"]
end
subgraph FinalState["Committed State"]
SaveSpace["Committed to Space (SQLite)"]
RunContainer["Executed in Container / Remote API"]
end
DraftPage --> InspectDraft
InspectDraft --"Approve & Save"--> SaveSpace
InspectDraft --"Decline"--> RejectAction
ToolCall --> ReadOnlyCheck
ReadOnlyCheck --"Yes (readOnlyHint: true)"--> AutoExecute
ReadOnlyCheck --"No (State-Modifying)"--> ApprovalCard
ApprovalCard --"Owner Approves"--> RunContainer
ApprovalCard --"Declined"--> RejectAction
AutoExecute --> RunContainer
1. Review Before Saving Workflows
When an agent compiles a research report, technical document, or project brief, it does not immediately overwrite existing workspace pages. Instead, the agent invokes a human-in-the-loop review card:
- The conversation stream pauses, rendering an interactive diff preview card in the timeline.
- The user inspects the proposed content and selects either Approve & save or Decline.
- Upon approval, the server writes the page to the authorized Space and returns a deep link. If the user declines or requests modifications, the agent ingests the feedback and generates a revised draft.
- Idempotency Protection: If a network timeout occurs, retrying the approval using the exact draft hash recovers the original page rather than generating duplicate database entries.
2. Model Context Protocol (MCP) Approval Architecture
OpenDots integrates deeply with the open Model Context Protocol (MCP) via Streamable HTTP endpoints. This enables developers to connect Dots to external systems such as GitHub, Jira, PostgreSQL databases, Google Workspace, and internal enterprise microservices.
To prevent prompt injection attacks from triggering unauthorized state changes (such as deleting an issue or sending an unauthorized email), OpenDots implements strict tool classification:
- Autonomous Read-Only Execution: Tools that publish a verified
readOnlyHint(such as searching a repository, reading a file, or fetching an issue list) execute autonomously without interrupting the user. - Ask-First Approval Cards: Any tool capable of mutating state (creating branches, updating records, sending communications) is intercepted by the server. The execution halts, and OpenDots generates an inline approval card detailing the exact arguments passed to the tool.
- Tamper-Proof Argument Execution: To prevent cross-site request forgery and client-side prompt manipulation, the OpenDots server caches the exact tool arguments generated by the model. When the user clicks Approve & run, the server executes the stored server-side payload through an owner-authenticated route, ignoring any parameter tampering attempted by client-side scripts.
For detailed best practices on securing agent execution environments against adversarial inputs, consult our comprehensive guide on Agent Tool Hardening.
Multi-Surface Reach: Web, Real-Time Voice, and Slack
A true digital coworker cannot remain sequestered inside an isolated browser tab. OpenDots implements a multi-surface communication layer that maintains shared state across text chats, voice calls, and enterprise messaging platforms.
1. Continuous Text Chat & Action Feeds
The primary web interface features a unified conversational timeline. Above the chat, the selected Dot’s avatar, status indicator, and active workspace permissions remain visible. Within the stream, traditional textual responses are interspersed with live action receipts, expandable tool outputs, file download pills, and container status badges.
2. Real-Time Voice Calls with Asynchronous Compute Agents
OpenDots includes a WebRTC-powered voice calling interface, allowing users to speak directly with their AI coworkers. However, real-time voice conversations typically struggle with computational latency: language models optimized for instantaneous speech cannot easily pause to execute a five-minute data scraping script.
OpenDots solves this through an architectural pattern called Compute Agent Bifurcation:
- The Voice Agent: A low-latency conversational model handles direct speech synthesis, listening, answering questions, and maintaining conversational rapport.
- The Compute Agent: When a complex task is requested during a call (such as analyzing a repository or generating a document), the voice agent delegates the task to a background compute agent running within the same conversation thread.
- Shared Context: Both agents operate within identical permission envelopes and reference the same working memory. The user can converse with the voice agent while watching live receipts from the compute agent populate on their screen.
The call interface provides real-time call duration timers, dual-speaker captions (transcribing both user and Dot speech), microphone/speaker mutes, and a seamless minimize button that lets users return to text chat without dropping the audio session.
3. Slack Integration via Channels SDK
Using CopilotKit’s Channels SDK and the open-source OpenTag architecture, OpenDots connects directly to Slack workspaces:
- Thread-Bound Interactions: Users mention a Dot (
@Scout summarize this thread) within any authorized Slack channel. The Dot joins the thread, evaluates the conversation context, and posts updates directly within the thread. - Strict Allowlisting: To maintain data governance, OpenDots requires an explicit workspace ID and user allowlist. Unauthorized Slack users cannot trigger background container executions or query private Spaces.
For teams comparing different orchestration engines for enterprise team messaging, see our comparative breakdown of Best Workflow Automation Software in 2026.
“What’s Available Today” Status Matrix
Because OpenDots is in active Alpha development, software evaluators must separate production-ready primitives from capabilities that require external infrastructure or live cloud credentials.
| Subsystem | Development Status | Required Infrastructure | Out-of-the-Box Local Behavior |
|---|---|---|---|
| Spaces & Pages Workspace | Fully Implemented (Alpha) | Node.js 24 + SQLite | Fully functional. Visual editor, slash commands, autosave, and local document library work immediately without external keys. |
| Specialist Dot Configuration | Fully Implemented (Alpha) | Local SQLite DB | Fully functional. Create agents, edit prompts, toggle tool permissions, and assign Space access locally. |
| CopilotKit Intelligence & Threads | Live Service Required | CopilotKit Hosted API or Local Docker Preview | Conversation persistence requires valid project keys (CPK_INTELLIGENCE_API_KEY). Without them, the app prompts for configuration. |
| Model Inference (BYOK) | Fully Implemented | OpenAI-compatible endpoint | Connects to any standard API (OpenAI, Anthropic via gateway, DeepSeek, or local Ollama/vLLM) via .env. |
| Dot Computers (OpenBot) | Verified Template | Docker Engine + Compose v2 + BuildKit | Requires building compose.computers.yml. Unconfigured deployments safely disable computer tools without running commands on the host. |
| Streamable HTTP MCP Connections | Fully Implemented (Alpha) | Remote MCP Server HTTP endpoint | Connects to remote endpoints, dynamically fetches tool schemas, and enforces HITL approval cards. |
| Real-Time Voice Calls | Preview Architecture | WebRTC / Speech Provider Credentials | Interface and compute delegation are functional; voice synthesis requires external provider API keys. |
| Managed Slack Integration | Early Preview | Slack App + Public HTTPS URL (Tunnel) | Requires Channels SDK setup, valid Slack bot tokens, and public webhook reachability. |
OpenDots vs. OpenAI Dots: Detailed Comparison
The announcement of OpenDots immediately prompted comparisons with OpenAI’s native Dots initiative. While both share the conceptual vision of persistent, always-on AI coworkers, their underlying philosophies, hosting models, and enterprise risk profiles are fundamentally divergent.
| Architectural Feature | OpenDots (CopilotKit) | OpenAI Dots (Proprietary Cloud) |
|---|---|---|
| Software License | MIT Open Source (Self-hosted template) | Proprietary closed SaaS (Commercial subscription) |
| Deployment Model | Self-hosted on local hardware, Docker, or private VPC | Fully managed on OpenAI cloud infrastructure |
| Model Compatibility | Model Agnostic: Any OpenAI-compatible provider (Claude, DeepSeek, local LLMs) | Restricted to OpenAI models (GPT-4o, o1, etc.) |
| Execution Environment | Isolated Docker containers per agent via OpenBot | Sandboxed multi-tenant cloud runtimes |
| Extensibility Protocol | Open Model Context Protocol (MCP) over Streamable HTTP | Proprietary OpenAI Actions and Platform Connectors |
| Document Storage | Local SQLite database (DATABASE_PATH) under your control |
Proprietary cloud document stores |
| Human Governance | Strict HITL approval cards for state mutations and document saves | Platform-determined policy boundaries |
| Data Privacy | Zero data shared outside your configured model provider | Subject to cloud provider terms and enterprise agreements |
| Customizability | 100% full-stack control (modify React UI, Node backend, and container supervisor) | Restricted to provided settings and developer portal toggles |
For organizations operating under stringent data residency mandates (such as HIPAA, GDPR, or internal intellectual property policies), OpenDots provides the only viable path to deploying persistent coworker agents without exposing proprietary operational documents to third-party multi-tenant clouds.
Real-World Cost Analysis: Software vs. Compute vs. Inference
A common misconception in the open-source community is that “open-source software equals zero operational cost.” While the OpenDots codebase is 100% free under the MIT License, running persistent AI coworkers introduces three distinct operational expenditure categories:
1. Software Licensing ($0 / Free)
The core OpenDots repository, the OpenBot supervisor scripts, and the AG-UI protocol integration are free and open-source under the MIT license. You can fork the repository, modify the source code, deploy it commercially, and distribute internal variations without licensing royalties.
2. Infrastructure & Container Compute ($0 to $45/month)
- Local Development: Running OpenDots on an engineering workstation (macOS, Linux, or Windows with WSL2) costs $0 in hosting fees.
- Team Server Deployment: Running OpenDots with 3–5 active Dot Computers requires a dedicated virtual machine or cloud instance. Because each Dot Computer runs an isolated Docker container with a Chromium instance, recommended specifications start at 4 vCPUs and 16 GiB of RAM. A standard VPS or cloud instance meeting these specs typically costs between $20 and $45 per month on providers like Hetzner, DigitalOcean, or AWS EC2.
3. Model Inference Costs (Pay-As-You-Go)
OpenDots operates on a Bring Your Own Key (BYOK) model. The ultimate monthly operational cost depends entirely on your model selection and agent workload:
- High-End Commercial Models (GPT-4o, Claude 3.5 Sonnet): Performing multi-step research, web navigation, and document drafting across 4 active Dots can consume between 1 million and 5 million tokens monthly, translating to $15 to $50 per month in API charges.
- Cost-Efficient Frontier Models (DeepSeek-V3, GPT-4o-mini): Utilizing cost-efficient reasoning models drastically lowers inference costs to under $5 to $10 per month.
- Zero-Cost Local Inference: By configuring
OPENAI_BASE_URLto point to a local Ollama or vLLM server running open-weights models (such as Llama 3.3 or Qwen 2.5 Coder), developers with capable local hardware can eliminate API inference costs entirely. For a deep dive into running local coding models without token caps, consult our guide to the Best Free Unlimited AI Coding Tools.
4. CopilotKit Intelligence Backend
OpenDots relies on CopilotKit Intelligence for conversation threading and state persistence. Developers can choose between:
- Hosted Intelligence: Free under the Developer plan for testing and early development.
- Local Intelligence Evaluation: A renewable 30-day evaluation preview running via Docker Desktop on macOS.
- Self-Hosted Enterprise Intelligence: Licensed deployment for enterprise infrastructure requiring complete on-premises air-gapping.
Step-by-Step Installation and Setup Guide
Deploying OpenDots locally takes less than ten minutes. Ensure your development environment meets the following prerequisites:
- Node.js: Version 24.x LTS.
- Package Manager:
npm(v10+). - Container Runtime: Docker Desktop or Docker Engine with Compose v2 and BuildKit enabled.
- API Credentials: An active API key for an OpenAI-compatible model provider.
Step 1: Clone the Repository and Install Dependencies
Open your terminal and clone the official repository:
git clone https://github.com/CopilotKit/OpenDots.git
cd OpenDots
npm ci
Step 2: Configure Environment Variables
Create your local environment configuration file:
cp .env.example .env
Open .env in your preferred editor. At a minimum, provide your model provider credentials:
# Model Configuration
OPENAI_API_KEY=sk-your-openai-or-compatible-api-key
OPENAI_MODEL=gpt-4o
# Optional: Point to custom endpoints (e.g., LiteLLM, Ollama, OpenRouter)
# OPENAI_BASE_URL=https://api.groq.com/openai/v1
# Application Secrets
OWNER_ID=admin-user
DATABASE_PATH=./data/opendots.sqlite
APP_ORIGIN=http://localhost:5173,http://127.0.0.1:5173
Step 3: Connect CopilotKit Intelligence
To enable persistent conversation threads, link your installation to a CopilotKit project:
npx copilotkit@latest login
npx copilotkit@latest project select
The CLI will authenticate your session via your browser, allow you to create or select a project, and automatically inject CPK_INTELLIGENCE_API_KEY into your .env file.
Step 4: Build and Launch Dot Computers (Optional but Recommended)
If you plan to utilize autonomous browser navigation, file sandboxing, and terminal capabilities, configure the Docker supervisor:
- Generate two secure, random secrets (at least 24 characters each) and add them to
.env:COMPUTER_SUPERVISOR_URL=http://127.0.0.1:4312 COMPUTER_SUPERVISOR_TOKEN=generate_random_secret_string_here_32_chars COMPUTER_TOKEN=generate_different_random_secret_string_here_32 COMPUTER_NAMESPACE=opendots - Build the computer base images and start the supervisor daemon:
docker compose -f compose.computers.yml build computer-image computer-supervisor docker compose -f compose.computers.yml up -d computer-supervisor
Step 5: Launch the Development Environment
Start the full-stack development server:
npm run dev
The React frontend interface will be available at http://127.0.0.1:5173, with the background API server operating on port 4310.
For teams interested in configuring external tooling protocols like MCP into local developer environments, review our walkthrough on How to Use MCP in OpenCode.
Current Limitations & Engineering Verdict
While OpenDots represents an impressive leap forward for open-source autonomous agent architectures, engineering teams must evaluate its current constraints objectively:
Key Limitations in Alpha
- Alpha Template Maturity: The project is an evolving architectural template, not a polished turnkey product. Developers should expect occasional breaking schema migrations and UI rough edges.
- Container Host Resource Overhead: Running multiple concurrent Dot Computers with headless Chromium instances consumes non-trivial RAM and CPU. Scaling beyond 5 concurrent active agent containers requires deliberate container orchestration.
- Voice & Slack Setup Overhead: While the local web application works smoothly out of the box, setting up WebRTC voice providers and configuring Slack webhooks requires navigating external developer portals and tunnel configurations.
- Strict Node.js 24 Requirement: The backend relies on newer Node.js runtime features; attempting to run the repository on Node 18 or 20 will cause runtime exceptions during build and execution phases.
Who Should Use OpenDots?
- Full-Stack Engineers & Technical Founders: Teams looking to deploy tailored internal AI coworkers with custom MCP connections, dedicated document storage, and branded UI components without proprietary cloud lock-in.
- Security & Privacy-Conscious Organizations: Enterprises that cannot permit proprietary LLM cloud providers to store internal strategy briefs, confidential source code, or internal database queries.
- AI Agent Researchers: Builders experimenting with multi-agent division of labor, human-in-the-loop governance patterns, and containerized agent execution environments.
Who Should Look Elsewhere?
Non-technical knowledge workers seeking an instantaneous, zero-configuration consumer app should remain on hosted tools such as Claude, ChatGPT Plus, or enterprise SaaS suites. OpenDots is built by developers, for developers.
Video Walkthrough: Building with Agentic Frameworks
To see how modern agentic interfaces and human-in-the-loop workflows function in production applications, watch this comprehensive technical breakdown:
Frequently Asked Questions
Is OpenDots completely free to use?
Yes, the OpenDots source code is completely free and licensed under the permissive MIT license. You can clone, modify, and host it on your own infrastructure without paying software licensing fees. However, you will incur standard infrastructure costs (server RAM/CPU for Docker containers) and pay-as-you-go model inference fees to your chosen LLM provider (such as OpenAI, Anthropic, or OpenRouter), unless you run fully local open-weights models via Ollama.
How does OpenDots differ from ChatGPT or Claude Coworker modes?
Commercial chatbots are multi-tenant, cloud-hosted SaaS applications where your prompts, document history, and agent interactions reside entirely on third-party vendor servers. OpenDots is a self-hosted template where documents live in your local SQLite database, agent execution occurs inside your own isolated Docker containers, and you have complete control over model routing, tool authorizations, and security policies.
Can I run OpenDots 100% offline with local LLMs?
Yes. OpenDots supports any OpenAI-compatible API endpoint via the OPENAI_BASE_URL environment variable. You can point it directly to a local instance of Ollama, vLLM, or LM Studio running models such as Llama 3.3, Mistral, or Qwen. For conversation threading, you can utilize the local Docker evaluation preview of CopilotKit Intelligence.
What happens if a Dot Computer crashes or goes offline?
OpenDots enforces a strict zero-fallback policy. If the OpenBot container supervisor is unavailable or a Dot Computer container terminates unexpectedly, the system will never fall back to executing commands on your host operating system. The tool call fails gracefully, logging an error in the timeline and preventing unauthorized host executions.
How does OpenDots prevent prompt injection attacks when executing MCP tools?
OpenDots implements a human-in-the-loop review barrier for all state-modifying tools. When an agent attempts to execute an action (such as writing to a database or triggering a webhook), execution halts and the server displays an approval card in the chat. The exact tool arguments are stored server-side. When the user approves the action, the server executes the stored payload directly, preventing malicious injection scripts from modifying execution parameters on the client.
What is the difference between a Space and an ordinary chat thread?
In standard chat applications, agent outputs are ephemeral messages that scroll out of view. In OpenDots, a Space is a dedicated project domain that houses living, editable Pages stored in SQLite. Agent research drafts and deliverables land as structured documents that team members can continuously edit, format, link, and collaborate on over time.

Yan ZC
Software Developer & Tech Reviewer
Software developer and tech reviewer at ToolReview. I test, analyze, and document AI tools and software workflows. My mission is to help you find the perfect tech stack with honest reviews and rigorous benchmarks.