Introducing dkod: The Agent-Native Code Platform

AI Agents Are the New Primary Authors of Code

The shift happened faster than anyone expected. In 2024, AI coding agents went from autocomplete novelties to autonomous contributors shipping production code. Cursor, Claude Code, Cline, Windsurf, Codex, T3 — these aren't assistants anymore. They read codebases, reason about architecture, write implementations, fix bugs, and submit changes.

But here's the problem we kept running into: the infrastructure wasn't built for them.

Git assumes human developers working sequentially. CI pipelines assume one change at a time. Code review assumes a human reading diffs. When you deploy five AI agents on the same codebase, everything that worked for human workflows starts to break — merge conflicts between agents that edited different functions, CI queues backed up with conflicting changes, silent overwrites when two agents modify the same file.

We built dkod to fix this.

What Is dkod?

dkod is an agent-native code platform — infrastructure designed from the ground up for AI agents to write, review, and ship code together.

It has three core capabilities:

Session Isolation

Every agent that connects to dkod gets an isolated workspace — a lightweight, copy-on-write overlay on top of the shared codebase. Writes go to the overlay, reads fall through to the base. No cloning, no worktrees, no file locks.

• 20+ agents work simultaneously on the same repo, same branch, same file
• Connect in < 50ms — vs. seconds-to-minutes for git clone
• Zero disk overhead for unmodified files
• Agents can't see each other's uncommitted changes

Semantic Merging

dkod understands code at the AST level — functions, types, constants, imports. When two agents modify different functions in the same file, dkod merges them automatically. When two agents modify the same function, dkod catches the real conflict and provides structured, symbol-level feedback.

• Two agents, different functions, same file → auto-merge
• Two agents, same function → conflict with precise context
• Agent A deletes a function Agent B calls → dependency conflict caught
• Merge time: < 50ms per changeset

Verification Pipeline

Verification is built into the protocol, not bolted on as a separate CI step. When an agent submits a changeset, the platform runs targeted verification — typechecking, affected tests, linting, custom invariants — and returns structured results the agent can act on immediately.

• Only affected tests run — not the full suite
• Structured failure data with AST context (not raw log output)
• Agents can auto-fix and resubmit without human intervention
• Full verification in < 30 seconds — vs. 5–30 minutes for traditional CI

The Agent Protocol

At the heart of dkod is the Agent Protocol — six operations that replace Git's clone/push/pull cycle:

Operation	What It Does	Performance
CONNECT	Establish isolated agent session	< 50ms
CONTEXT	Query semantic slices of the codebase	< 200ms
SUBMIT	Submit atomic, semantic changeset	< 100ms
VERIFY	Run targeted verification gates	< 30s
MERGE	Accept verified changeset into codebase	< 50ms
WATCH	Subscribe to real-time symbol changes	Streaming

The protocol runs over persistent WebSocket or gRPC connections. It's stateful — agents maintain sessions rather than performing stateless operations. And it's designed for machine consumption: every response is structured data, not text for humans to parse.

Works with Your Existing Agents

dkod integrates with the agents you already use through the MCP (Model Context Protocol) bridge:

• Claude Code — add dkod MCP to your config
• Cursor — MCP integration via settings
• Cline — MCP settings in VS Code
• Windsurf — MCP configuration
• Codex — CLI integration
• T3 — MCP bridge

You don't need to change your agents or your workflow. Install the MCP bridge, and your agents gain session isolation, semantic merging, and verification — transparently.

Getting Started

Install the CLI

cargo install --git https://github.com/dkod-io/dkod-engine dk-cli

Connect and Code

# Authenticate
dk login

# Initialize a session on your repo
dk init my-org/my-repo --intent "add input validation to all API endpoints"

# Read files
dk cat src/handlers/user.rs

# Write changes
dk add src/handlers/user.rs --content "..."

# Submit, verify, and merge
dk commit -m "add input validation to user handler"
dk check
dk push -m "validated user endpoints"

Or Use MCP with Claude Code

Add to your MCP settings:

{
  "mcpServers": {
    "dkod": {
      "command": "dk-mcp",
      "args": ["--repo", "my-org/my-repo"]
    }
  }
}

Then use the MCP tools in your agent workflow:

dk_connect    → establish session
dk_file_read  → read files from workspace
dk_file_write → make changes
dk_submit     → submit changeset for verification
dk_push       → merge verified changeset to main

Open Source, MIT Licensed

dkod is fully open source under the MIT license. The entire platform — the agent protocol engine, semantic merge engine, session isolation layer, verification pipeline, CLI, and MCP bridge — is available on GitHub.

We believe agent-native infrastructure should be a public good. AI agents are becoming ubiquitous. The platform they run on shouldn't be a proprietary lock-in.

What's in the repo:

• dkod-engine — the core platform in Rust: session management, semantic merging, code graph, verification
• dk-cli — command-line interface for human and agent use
• dk-mcp — Model Context Protocol bridge for IDE-integrated agents
• Agent Protocol spec — the full protocol definition

What's Next

We're launching with support for Rust, TypeScript, Python, Go, and Java — with more languages coming fast (the AST layer is tree-sitter-based, so adding languages is straightforward).

On the roadmap:

• Hosted platform — managed dkod for teams that don't want to self-host
• Agent orchestration — coordinate multiple agents on complex tasks with dependency-aware scheduling
• Conflict resolution agents — specialized agents that resolve semantic conflicts autonomously
• IDE plugins — first-class VS Code and JetBrains integration

Join Us

• GitHub: github.com/dkod-io/dkod-engine
• Docs: dkod.io/docs
• Discord: discord.gg/q2xzuNDJ
• Twitter: @dkod_io

We built dkod because we needed it — and because we believe every team deploying AI agents will need it too. Try it, break it, contribute to it. The age of agent-native development is here.

---

This is the fourth post in our series on agent-native development. Previously: Semantic Merging vs Git Merge. Next: Building a Multi-Agent Verification Pipeline.