# dmx

> An open-source AI-native engineering harness that runs as an MCP server inside Cursor, Claude Code, and Copilot, wrapping AI workflows in structured, verifiable loops with human gates.

dmx is an open-source orchestrator for AI-native engineering, built by DeepModel, Inc. and licensed under AGPL-3.0. It runs as an MCP server inside Cursor, Claude Code, GitHub Copilot, and Antigravity, adding a structured governance layer on top of whatever AI IDE you already use. The project implements the AI SDLC framework — a five-phase workflow (Spec → Plan → Build → Validate → Release) with explicit human control points at every phase boundary.

## What It Is

dmx is an **agent harness** — a category of tooling that sits between the AI model and the developer's codebase, enforcing process rather than improving the model itself. Where tools like Cursor and Claude Code are execution engines optimized for speed, dmx adds the structure those tools lack: ordered phases, mandatory human gates, automated validators, and persistent project memory. The core insight is that faster execution of an unstructured process is still an unstructured process.

## How the Loop Runtime Works

The central abstraction in dmx is the **loop** — a declarative YAML config that defines an ordered skill sequence, a validator policy, a human gate, and optional chaining to the next loop. Loops ship as bundled defaults and can be overridden per-project via `.dmx/loops/{name}.yaml`, which is committed to the repo and reviewed in PRs like any other code change.

- **Foreground mode**: developers invoke `/dmx/*` skills manually — they are the orchestrator.
- **Background mode**: the loop runtime runs the sequence, invokes validators, and pauses at human gates.
- **Validators** are plain Python functions at `validators/{name}.py` in the app repo. Required validators block loop advancement; optional validators warn. The policy is explicit and version-controlled.
- **Persistent job state**: every loop run writes to `.dmx/loop-state.json` (active pointer) and `.dmx/jobs/{job_id}/` (per-run history). Close the IDE and resume tomorrow with `/loop-continue`.

The bundled SDLC pipeline chains five loops: `spec → plan → dev → validate → release`.

## The Memory Bank

The `.dmx/` directory is committed to the repository and serves as the project's shared memory. Every AI session — and every developer — starts from the same context without re-explaining the project. Key files include:

- `projectbrief.md`, `productContext.md`, `systemPatterns.md`, `techContext.md` — durable context updated when architecture or features change
- `activeContext.md` — a branch-local learning inbox promoted to durable files on commit or PR
- `spec.md` and `tasks.md` — branch-scoped artifacts created by the spec and plan loops
- `loops/` — team-shared loop config overrides

A three-tier memory sync model keeps context current: `/dmx/commit` does a light sync, `/dmx/create-pr` does a full sync, and `/dmx/update-memory` does a deep reconciliation on demand.

## Team and Monorepo Setup

dmx is designed for team use. One developer runs `/dmx/init` once per repository; every subsequent developer clones the repo and gets the full memory bank automatically. Each developer connects their IDE to dmx as an MCP server using the same `uvx`-based config — no per-developer secrets or configuration. Loop configs and custom validators live in the repo, versioned and reviewed like code. For monorepos, dmx initializes at the repository root with one `.dmx/` memory bank per repo; teams scope each ticket explicitly in the spec to keep AI work bounded to the relevant services and directories.

## Update: v0.3.1

The latest release is **v0.3.1**, published on 2026-08-29. The project reached its M1 milestone (tracked as issue #5), which delivered the full loop runtime: config, state persistence, MCP orchestration (`run_loop`, `loop_advance`, `loop_continue`), human-gate sequencing, validator execution, the policy engine, `repeat_until` iteration, `on_complete` auto-chaining, and loop-level memory hooks. The M1 milestone is covered by an end-to-end integration test suite that runs the full `spec → plan → dev → validate → release` pipeline through the real MCP tools. Upcoming roadmap items include a hosted team server (shared MCP endpoint, shared loops and rules) and a gateway for model governance and cost visibility.

## Features
- MCP server for Cursor, Claude Code, GitHub Copilot, and Antigravity
- Five-phase AI SDLC workflow: Spec, Plan, Build, Validate, Release
- Declarative loop configs in YAML, versioned in the repo
- Human gates at every phase boundary — AI cannot advance without approval
- Automated validators with required/optional policy enforcement
- Persistent job state across IDE sessions via .dmx/ directory
- Shared memory bank committed to the repo for team context
- Three-tier memory sync: commit, PR, and on-demand deep reconciliation
- Full skill catalog: create-ticket, plan, implement-next-phase, validate, create-pr, create-release
- Custom validators as plain Python functions
- Monorepo support with repo-root initialization
- Progressive trust model: relax human gates based on validator history
- Loop-level memory hooks surfacing open learnings before each skill run
- No separate install — runs via uvx on demand

## Integrations
Cursor, Claude Code, GitHub Copilot, Antigravity, Jira, GitHub, uvx / uv

## Platforms
CLI, API, VSC_EXTENSION

## Pricing
Open Source

## Version
v0.3.1

## Links
- Website: https://dmx.deepmodel.ai
- Documentation: https://dmx.deepmodel.ai/quick-start
- Repository: https://github.com/deepmodel-ai/dmx
- EveryDev.ai: https://www.everydev.ai/tools/dmx