Tools & Products

OpenDots: CopilotKit Releases Self-Hostable, Always-On AI Coworkers Compatible with Any Agent Harness

CopilotKit open-sourced OpenDots, an autonomous, self-hostable runtime enabling background AI coworkers that persist across sessions, maintain long-term team memory, and plug into LangGraph, CrewAI, AutoGen, and custom agent loops.

By FreakVinci · 2026-10-03 · 13 min read

CopilotKit released OpenDots as an open-source project on GitHub (github.com/CopilotKit/OpenDots). The repository provides a self-hostable runtime designed to run persistent, always-on AI coworkers that integrate directly into existing developer and business toolchains.

Unlike conventional chatbots that spin up on a user prompt and terminate upon response completion, OpenDots runs continuous background daemons capable of reacting to webhooks, scheduled cron jobs, database state changes, and team chat channels.

Core Difference: Ephemeral Chatbots vs. OpenDots Coworkers

Most agent frameworks require developers to construct custom queueing, thread locking, and database sync logic to keep agents alive beyond single API calls. OpenDots packages this operational plumbing into a standardized runtime.

Dimension Standard Chatbot / Agent Sandbox OpenDots Persistent Coworker
Lifecycle Ephemeral (terminates after turn) Always-on background daemon
Trigger Mechanism User submits text in input box Webhooks, cron triggers, git events, chat messages
Agent Harness Tied to a specific proprietary SDK Harness-neutral (LangGraph, CrewAI, AutoGen, custom)
Memory Retention In-memory token sliding window Multi-tier persistence (PostgreSQL + vector memory)
Hosting Model Proprietary multi-tenant SaaS 100% Self-hostable on Docker or Kubernetes
Action Approvals All-or-nothing tool calling Granular human-in-the-loop approval checkpoints

Harness Agnostic Architecture

OpenDots does not force teams to rewrite their existing agent prompts or state machines. Instead, it wraps existing agent definitions through a standardized protocol adapter.

┌────────────────────────────────────────────────────────┐
│                   Trigger Sources                      │
│   GitHub Webhooks │ Slack Events │ Linear │ Cron Schedule │
└──────────────────────────┬─────────────────────────────┘
                           │
                           ▼
┌────────────────────────────────────────────────────────┐
│                   OpenDots Daemon                      │
│  • Event Router        • Session State Store (Postgres)│
│  • Memory Graph        • Permission & Approval Gates   │
└──────────────────────────┬─────────────────────────────┘
                           │
           ┌───────────────┼───────────────┐
           ▼               ▼               ▼
     [LangGraph]       [CrewAI]       [Custom Node]
     Agent Graph      Multi-Agent      Simple Loops

Whether your engineering team built an internal research agent in LangGraph or a triaging crew in CrewAI, OpenDots connects to the runner over HTTP or gRPC, handles message serialization, and coordinates background execution.

Quickstart: Deploying OpenDots Locally with Docker

To deploy a local OpenDots cluster with PostgreSQL and a persistent worker, clone the repository and run the setup script:

# 1. Clone the official repository
git clone https://github.com/CopilotKit/OpenDots.git
cd OpenDots

# 2. Configure environment credentials
cp .env.example .env
# Set your model provider keys (OpenAI, Anthropic, or Ollama endpoint)

# 3. Spin up the cluster
docker compose up -d

# 4. Confirm daemon health
curl -f http://localhost:8080/health

The Docker Compose configuration spins up:

  • OpenDots Core: The Node.js/Go event orchestration engine.
  • PostgreSQL + pgvector: Stores conversation states, semantic memories, and event logs.
  • Web Dashboard: An administration UI to monitor coworker status, inspect active tasks, and approve pending human-in-the-loop requests.

Writing an OpenDots Worker in TypeScript

Connecting a custom agent script into OpenDots requires minimal boilerplate:

import { OpenDotWorker, AgentTrigger } from '@copilotkit/opendots';

// Define a coworker dedicated to GitHub PR triage
const prTriageCoworker = new OpenDotWorker({
  name: 'PR-Reviewer-Bot',
  description: 'Audits open PRs for unit test coverage and breaking API contracts',
  triggers: [
    AgentTrigger.webhook('github.pull_request.opened'),
    AgentTrigger.cron('0 9 * * 1-5') // Daily 9 AM summary
  ],
  async execute({ event, memory, tools }) {
    const prDetails = event.payload;
    
    // Retrieve historical team conventions from long-term memory
    const conventions = await memory.search('api formatting standards');
    
    // Evaluate the patch
    const analysis = await tools.analyzeDiff(prDetails.diffUrl, conventions);
    
    if (analysis.hasBreakingChanges) {
      // Pause execution and notify the lead engineer
      await tools.requestHumanApproval({
        action: 'Post breaking change warning',
        details: analysis.summary,
        reviewerRole: 'tech-lead'
      });
    }
  }
});

prTriageCoworker.start();

Enterprise Security and Data Privacy

Because OpenDots runs entirely within the user's infrastructure, sensitive internal documents, customer support logs, and private code repositories never transit through third-party agent hosting clouds.

Teams with strict compliance constraints (SOC 2 Type II, HIPAA, or air-gapped defense networks) can pair OpenDots with locally served models running on vLLM or Ollama, creating an autonomous agent coworker network operating completely offline.