# Harness Control Plane: One Dashboard for All Your AI Coding Tools

> HCP - open-source control plane for Claude Code, Codex, Gemini, Cursor, Windsurf, Copilot. Auto-discovery, symlinks, drift detection.
> Author: Roman Belov · Published: 2026-04-17 · Source: https://futurecraft.pro/blog/harness-control-plane/

Here's the situation: [Claude Code](/blog/claude-code-complete-guide/) uses `.claude/commands/`, Codex CLI uses `.codex/skills/`, Gemini uses `.gemini/skills/`. Different formats, different directories, different configs. You write a good skill for Claude - then manually copy it to Codex. You set up an [MCP server](/blog/mcp-production-custom-servers/) in one project - a month later you can't remember where else you configured it.

More tools, more mess. Config sprawls across the filesystem and stops fitting in your head. I hit this wall when my skills count passed a hundred and MCP servers crossed a dozen. Harness Control Plane is the tool I built to fix it.

## What HCP does

HCP scans configs across seven AI tools and builds a map of every asset:

| Tool | What HCP scans |
|------|--------------|
| Claude Code | `~/.claude/commands/`, `~/.claude/agents/`, `~/.claude/rules/`, `.mcp.json`, `CLAUDE.md` |
| Codex CLI | `.codex/skills/`, `.codex/agents/`, `.codex/mcp.json`, `AGENTS.md` |
| Gemini CLI | `.gemini/skills/`, `.gemini/mcp.json`, `GEMINI.md` |
| Cursor | `.cursor/rules/`, `.cursorrules` |
| Windsurf | `.windsurf/rules/`, `.windsurf/mcp.json`, `.windsurfrules` |
| GitHub Copilot | `.github/copilot-instructions.md` |
| Continue.dev | `.continue/config.json` |

It's a control plane — discovery, connection, sync, history, rollback. Not monitoring. Not analytics.

## Symlinks over copies

The core idea behind HCP is connecting assets through file symlinks.

Say you have a skill called `deploy-checklist` in Claude Code. You need it in Codex CLI too. Copying the file is a path to desync. A week later the original is updated, the copy isn't.

HCP creates a symlink: `.codex/skills/deploy-checklist.md` → `~/.claude/commands/deploy-checklist.md`. One file, one edit point. Claude, Codex, Gemini - they all read the same thing. Edit it once, every tool sees the change instantly.

Why this works: every tool on that list stores its config in files. No proprietary storage - markdown, JSON, YAML. Symlinks solve the sync problem without a single line of sync logic.

Disconnecting is atomic: the symlink gets removed, the original stays untouched. HCP tracks directionality - you can't accidentally delete the source file from a connected tool's UI.

[AgentSync](/blog/agentsync-mcp-config-sync/) solves a related problem - syncing MCP configs between projects. HCP operates at a different level: between tools.

## Ecosystem Map

On first launch, HCP scans the filesystem and builds an interactive map. Each asset is a card with type, provider, category, and content.

Filters: by type (skills, agents, MCP servers, rules), by provider (Claude, Codex, Gemini...), by category. HCP auto-sorts assets into 9 categories - from SEO & GEO and Security & QA to Development and Code Quality. Filter settings persist between sessions.

Search by name, description, and tags. Once you have 200+ assets, this stops being a convenience and becomes a necessity.

## History and rollback

Every action - create, connect, disconnect, delete - goes into an audit log. SQLite, local, no external dependencies.

The UI shows a timeline. Undo the last action with one button. Roll back to a specific point - same thing. HCP stores state snapshots on every change.

For teams, it's an audit trail: who connected that MCP server, when, from which client. For solo developers, it's insurance against accidental deletion.

## Two interfaces

### macOS App

Native SwiftUI app. Download the DMG, drag to Applications. It auto-launches the local agent on startup.

Keyboard shortcuts: `Cmd+F` for search, `Cmd+N` to create an asset, `Cmd+Z` for undo, `Cmd+R` to rescan.

### CLI + Web UI

```bash
npx harness-control-plane
```

One command - browser opens at `localhost:3000`. React + TypeScript + Tailwind. Same features as the macOS app.

For servers and VPS:

```bash
hcp --headless -p 3000
# From your local machine:
ssh -L 3000:localhost:3000 user@your-vps
```

One-shot mode for CI/CD:

```bash
hcp scan              # Summary to stdout
hcp scan -o map.html  # Self-contained HTML file
```

## Architecture

```
harness-control-plane/
├── bin/cli.js            # CLI entry point
├── agent/
│   ├── server.js         # HTTP + WebSocket server
│   ├── router.js         # REST API (40+ endpoints)
│   ├── scanner/          # Auto-discovery across 7 tools
│   ├── connector/        # Connect/disconnect via symlinks
│   ├── sync.js           # Cross-provider sync
│   ├── drift.js          # Drift detection across copies
│   ├── health.js         # Asset health checks
│   ├── snapshots.js      # Rollback snapshots
│   └── store/            # SQLite state
├── desktop/              # macOS SwiftUI
└── ui/                   # React + TypeScript + Tailwind
```

Two dependencies: `better-sqlite3` for storage, `ssh2` for remote access. Everything else is Node.js stdlib.

A file watcher tracks config changes. On any change, a WebSocket event (`assets:updated`) fires and the UI updates instantly. State survives restarts via SQLite.

The REST API covers full CRUD: creating, reading, updating, deleting assets, connecting and disconnecting between tools, rescanning, history, rollback.

## Drift Detection

Say an asset is connected via symlink to three tools. Someone bypasses HCP and edits the file directly in `.codex/skills/` - the symlink breaks, the file becomes a regular copy.

HCP catches this automatically. Drift detection compares the original against connected endpoints and flags the divergence. Recovery is straightforward — recreate the symlink or pull the latest version. I've been bitten by silent desync before; this is the part that saves you from debugging phantom differences at 2 AM.

## When you need this (and when you don't)

Two conditions:

1. You use more than one AI coding tool
2. You've accumulated a non-trivial set of assets - skills, agents, MCP servers

Typical scenario: Claude Code as your main tool, Cursor for IDE integration, Codex CLI for a second opinion. 50+ skills, 10+ MCP servers. Without a single map, you're doing manual sync and losing track. HCP removes that manual work.

If you only use one tool, HCP will show you a nice asset map, but you won't need the cross-provider stuff. It scales with your chaos.

Beta limitations: the Projects, Servers, Bundles, and Policies sections are hidden in the UI while being finalized. Windows support hasn't been tested. Symlinks on Windows work but may require Developer Mode.

## Installation

macOS app - [DMG on GitHub Releases](https://github.com/spyrae/harness-control-plane/releases/latest). Requires Node.js 18+.

CLI:

```bash
# One-time run
npx harness-control-plane

# Global install
npm install -g harness-control-plane
hcp
```

The project is in beta (v0.1.0). BSL 2.0 license - free to use, auto-converts to MIT in 2030.

GitHub: [github.com/spyrae/harness-control-plane](https://github.com/spyrae/harness-control-plane)
npm: [npmjs.com/package/harness-control-plane](https://www.npmjs.com/package/harness-control-plane)

---

*Need help managing AI developer tooling? I help startups build AI products and automate processes — [belov.works](https://belov.works).*