dkod

Quickstart

Get up and running with dkod in under 5 minutes.

The best option for Claude Code users. The dkod plugin bundles everything — MCP tools, the parallel execution skill, agents, and commands — into a single install.

/plugin marketplace add dkod-io/dkod-plugin
/plugin install dkod@dkod

That's it. You get:

  • MCP tools — dk_connect, dk_context, dk_file_read, dk_file_write, dk_file_list, dk_submit, dk_verify, dk_approve, dk_resolve, dk_merge, dk_push, dk_status, dk_watch, dk_review
  • Parallel execution skill — teaches the agent to decompose work by symbol and launch concurrent sub-agents
  • Commands — /dkod:status, /dkod:push, /dkod:watch, /dkod:land (chains approve → merge → push)
  • Agents — pre-built multi-agent orchestrator

On first use, a browser window opens for GitHub OAuth authentication. After that, dkod tools are available in all future sessions.

Alternative: Install the Skill

If you prefer a lighter setup, or use an agent other than Claude Code (Cursor, Codex, Windsurf, Cline, etc.), install the dkod skill. It teaches the agent to parallelize work, use dkod's MCP tools, and handle conflicts automatically. If the MCP server isn't configured yet, the skill walks the agent through setting it up on first use.

npx skills add dkod-io/dkod-plugin

Your agent now has the /dkod command. Works with Claude Code, Cursor, Codex, Windsurf, Cline, and any skills-compatible agent. See the full Agent Skill guide for details.

Alternative: MCP + CLI

If you prefer to set things up step by step, or need more control over the configuration:

Cloud (dkod.io)

No servers to manage — just connect your agent via MCP. The CLI is optional for direct terminal access.

1. Connect your agent via MCP

Add the dkod MCP server to your agent. For example, with Claude Code:

claude mcp add --transport http dkod https://api.dkod.io/mcp

On first use, a browser window opens for GitHub OAuth authentication. After that, dkod tools are available in all future sessions.

See the full list of agent setup guides: Claude Code, Cursor, Cline, Codex, Windsurf, T3 Code, Gemini CLI.

2. (Optional) Install the CLI

The CLI gives you direct terminal access to dkod for project initialization, status checks, and manual operations. It's not required for agent workflows — the MCP server handles everything.

# Install via Cargo (requires Rust)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
cargo install --git https://github.com/dkod-io/dkod-engine dk-cli
dk login     # Authenticate via GitHub OAuth
dk init      # Connect your repo to dkod (auto-detects from git remote)

Self-Hosted

Run the open-source dkod engine on your own infrastructure. Full control over your data and deployment.

1. Start the engine

Run the dkod engine with Docker (requires PostgreSQL 16+):

docker run -d \
  -p 50051:50051 \
  -p 8080:8080 \
  -e DATABASE_URL=postgres://user:password@host.docker.internal/dkod \
  -e AUTH_TOKEN=your-secret-token \
  ghcr.io/dkod-io/dkod-engine:latest

The engine is now running on 0.0.0.0:50051 (gRPC) and 0.0.0.0:8080 (HTTP/MCP).

2. Connect your agent via MCP

claude mcp add --transport http dkod http://localhost:8080/mcp

For other agents, see the Self-Hosted sections in each agent guide: Claude Code, Cursor, Cline, Codex, Windsurf, T3 Code, Gemini CLI.

3. (Optional) Install the CLI

Install Rust if needed, then:

cargo install --git https://github.com/dkod-io/dkod-engine dk-cli
export DKOD_AUTH_TOKEN=your-secret-token
dk --server localhost:50051 init

Connect from code (Python SDK)

from dkod import DkodClient, ContextDepth

client = DkodClient("agent.dkod.io:443", auth_token="dkod_key_...")
session = client.connect("org/repo", "Add input validation to API")

ctx = session.context(
    "All API endpoint handlers",
    depth=ContextDepth.FULL,
    include_tests=True,
)

# ... make changes ...
result = session.submit(changes, "Add input validation to the API")

Connect from code (Rust SDK)

use dk_agent_sdk::{AgentClient, Depth};

// Cloud
let mut client = AgentClient::connect("https://agent.dkod.io:443", "dkod_key_...").await?;
// Self-hosted: AgentClient::connect("http://localhost:50051", "my-token")
let mut session = client.init("org/repo", "Add input validation").await?;

let ctx = session.context("All API endpoint handlers", Depth::Full, 4000).await?;

What happens behind the scenes

When an agent connects:

  1. Session created — the platform creates an isolated workspace (copy-on-write overlay over the current codebase state)
  2. Semantic graph ready — the agent can immediately query functions, classes, call graphs, and dependencies
  3. Full isolation — any changes the agent makes are invisible to other agents and to the main branch until submitted and merged
  4. Auto-rebase — if the main branch moves while the agent is working, dkod automatically rebases compatible changes
  5. Code review — every dk_submit returns a local review summary (score and findings count); call dk_verify explicitly for lint, type-check, and tests

What's next?