es
What Is OpenDots? The Open-Source AI Coworker Platform Explained
ai tools

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.

T
ToolReview
Published: October 6, 2026

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.

OpenDots autonomous agent workspace and coworker interface

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:

  1. 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.
  2. 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.
  3. 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:

  1. Workspace Storage: A sandboxed /workspace filesystem 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.
  2. 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:

  1. The conversation stream pauses, rendering an interactive diff preview card in the timeline.
  2. The user inspects the proposed content and selects either Approve & save or Decline.
  3. 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.
  4. 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_URL to 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.

If you plan to utilize autonomous browser navigation, file sandboxing, and terminal capabilities, configure the Docker supervisor:

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

  1. 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.
  2. 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.
  3. 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.
  4. 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

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.