What is Harness Control Plane?

Harness Control Plane is an open-source dashboard that auto-discovers all AI developer assets (skills, agents, MCP servers, rules) across 7 tools (Claude Code, Codex, Gemini, Cursor, Windsurf, Copilot, Continue.dev) and lets you manage them from a single interface.

How does HCP sync assets between tools?

Via file symlinks. When connecting an asset from Claude Code to Codex CLI, HCP creates a symlink - not a copy. Changes to the original are instantly visible in all connected tools.

Can I use HCP on a remote server?

Yes. HCP runs in headless mode (hcp --headless -p 3000), and you access the UI through an SSH tunnel.

Yes. BSL 2.0 license - free to use, modify, and self-host. The only restriction: you can't sell it as a competing product. The license automatically converts to MIT in 2030.

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

Here’s the situation: Claude Code 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 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 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

npx harness-control-plane

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

For servers and VPS:

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

One-shot mode for CI/CD:

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:

You use more than one AI coding tool
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. Requires Node.js 18+.

CLI:

# 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 npm: npmjs.com/package/harness-control-plane

Need help managing AI developer tooling? I help startups build AI products and automate processes — belov.works.