FREE & OPEN SOURCE // SELF-HOSTED REMOTE HARNESS

Autonomous Coding.
Isolated Sandboxes.
Zero Credential Leaks.

Cloud Harness MCP gives ChatGPT, Claude, Cursor, and Codex full execution power over isolated repository clones inside bounded Docker executors — plus managed coding agents, one MCP gateway for every other server, and a shared skill library. Docker host sockets and GitHub App secrets never leave the control plane.

100+
Structured Tools
5
Gateway Tools, Any MCP Server
$0
MIT Licensed, Self-Hosted
THE 3-MINUTE TOUR // WHAT CLOUD HARNESS MCP DOES
Clone, test, and push from ChatGPT or Claude — then hand the rest to managed agents, gateway servers, and shared skills.

System Architecture

One credential-free ingress, a trusted control plane that owns every secret and the Docker socket, and disposable execution containers that run repository code, managed agents, and Git transfers on separate rails.

● BOUNDARY TRACE — EDGE → CONTROL PLANE → EXECUTION → OUTBOUND PACKET FLOW: ACTIVE
Cloud Harness MCP system architecture AI clients reach a credential-free ingress proxy through Cloudflare Access and nginx. The API serves the MCP endpoint, the MCP gateway, events delivery, and the dashboard, and forwards work to the runner. The runner owns policy, encrypted state, Docker authority, and the GitHub broker, and feeds a separate model gateway service that holds provider keys only in memory. The runner starts a non-root workspace executor, Git transfer helpers, and managed agent containers. Outbound traffic goes to remote MCP servers, webhook callbacks, LLM providers, and GitHub. 01 // EDGE AI Clients ChatGPT • Claude • Cursor Codex • Gemini • any MCP Access + nginx Managed OAuth lane or API-key lane, TLS Ingress Proxy Zero secrets Loopback-only port 02 // TRUSTED CONTROL PLANE API /mcp • Dashboard BFF No socket, no host mounts MCP Gateway /mcp-gateway • 5 tools Pinned outbound sockets Events Delivery Terminal task/agent events Signed webhooks Runner Policy • Docker authority SQLite • AES-GCM keyring GitHub Broker Optional GitHub App Short-lived tokens Model Gateway Provider keys stay here Leases • cost budgets 03 // EXECUTION PLANE Workspace Executor Non-root • read-only root • TTL dependency-access | network-none Git Transfer Helpers Only hop with network + token Executor paused meanwhile Managed Agent Containers Pi agent • no secrets, no mounts Models only via gateway lease 04 // OUTBOUND Remote MCP Servers GitHub, Supabase, PostHog… Webhook Callbacks Public HTTPS only LLM Providers OpenAI, Anthropic, … GitHub Origin Clone, fetch, push
← Swipe horizontally to view the complete architecture →
Plane 01 // Edge & Ingress

Credential-Free Ingress

Cloudflare Access Managed OAuth is the authorization server at the perimeter, and the API verifies only the signed assertion Access forwards. Dashboard API keys use a separate lane. The ingress proxy holds no secrets and never joins the control network. How the OAuth lane works.

  • ✓ Managed OAuth via Cloudflare Access (GitHub/Google sign-in)
  • ✓ Separate API-key lane for static-header clients
  • ✓ The only host-published service, on loopback
Plane 02 // Trusted Control

API, Runner & Gateways

The API speaks MCP, serves the dashboard, fronts your downstream MCP servers, and delivers signed event webhooks. The runner alone owns the Docker socket, encrypted state, and GitHub App credentials, and feeds a separate model gateway that keeps provider keys out of every container.

  • ✓ Idempotent workspace and agent lifecycle
  • ✓ Write-only secrets in an AES-GCM keyring
  • ✓ Per-agent leases with pre-reserved budgets
Plane 03 // Execution Plane

Disposable Containers

Repository code runs in a non-root executor with a read-only root filesystem and resource caps. Dependency egress is the shipped default and network-none is the per-workspace or instance-wide opt-out. Managed agents and Git transfers each get their own short-lived container.

  • ✓ Non-root UID, no Docker socket, no control-plane credentials
  • ✓ Agent containers: no repository mounts, no secrets
  • ✓ Purged on workspace_close or TTL expiry

Bounded Coding Workflow

A high-velocity, deterministic sequence from workspace boot to safe git push and automatic sandbox purging.

agent@claude-code:~$ call mcp.workspace_open({

"repositoryUrl": "https://github.com/org/core-infra",

"idempotencyKey": "task_448f_09a1"

})


[200 OK] Streamable HTTP Connection Established (14ms)

├── Edge: Cloudflare Access accepted OAuth bearer; origin verified signed assertion

├── Runner: Ephemeral GitHub broker minted stdin-only push key

├── Docker: Spawned non-root executor (TTL: 1800s, net: dependency-access)

└── Workspace Ready: ws_8f93e120da4c71b2e9f0


agent@claude-code:~$ call mcp.exec_run({

"workspaceId": "ws_8f93e120da4c71b2e9f0",

"command": "npm test -- --bail"

})

✓ Test suite completed in 1.42s (0 host leaks, 0 socket mounts)

● SEQUENCE TRACE — TIME-LIMITED WORKSPACE LIFECYCLE 4-STAGE CONTINUOUS VERIFICATION
AI Client Control Plane Docker Executor GitHub Origin 1. workspace_open(repoUrl, idempotencyKey) 2. Ephemeral Git Clone (Token over stdin) 3. Spawn Non-Root Container (TTL: 30m, Net: Policy) 4. Returns opaque workspaceId 5. grep_search / files_apply_patch / shell_open / tasks_run 6. Real-time stream results (Zero host leaks) 7. git_push(refspec, forceWithLease) 8. Broker push via short-lived stdin helper 9. workspace_close → Container & volumes destroyed (0 residual state)
← Swipe horizontally to view full sequence workflow →

Every MCP Server. Just 5 Tools.

Register GitHub, Supabase, PostHog, Cloudflare, or any remote MCP server once. Your clients connect to a single /mcp-gateway URL whose tool list never grows, so adding servers never eats your context window.

Constant context cost

The gateway always exposes the same five tools. Agents search the cached catalog, inspect one tool's schema, then execute it, instead of loading hundreds of tool definitions up front.

Secrets by reference

Header values can point at a write-only global secret, and OAuth-protected servers connect from the dashboard. Clients never see the downstream credential.

Per-tool permissions and logs

Set a default allow or deny per server, override single tools, and review every call in the dashboard. Outbound sockets are validated and address-pinned.

MCP Gateway guide ↗

Spawn Coding Agents in the Cloud

Your client delegates a bounded task with agent_spawn, keeps working, and collects the result later. Each agent runs in its own disposable container against a workspace, with models reached only through the trusted model gateway.

Pi agent LIVE

A bounded Pi coding session with token, cost, and time budgets, ten safe file and search operations, and live status, logs, and follow-up messages.

Claude Code COMING SOON

Run Anthropic's coding agent as a managed runtime under the same container, lease, and budget boundary.

Codex COMING SOON

Run OpenAI's coding agent as a managed runtime under the same container, lease, and budget boundary.

Providers & model profiles

Store keys for OpenAI, Anthropic, OpenRouter, Google Gemini, DeepSeek, OpenCode Go, or any HTTPS endpoint you trust, then build model profiles with pricing, budgets, and tool permissions. Draft and validate profiles from your client with the model_* tools; keys, activation, and spend policies stay dashboard-only. No restart needed.

Keys never enter a container

Provider keys are write-only and encrypted at rest. Agents get an opaque, short-lived lease instead, and in-flight runs stay pinned to the exact profile revision they started with.

Spend you can cap

Every request reserves its worst case before it goes upstream. Set daily or monthly spend policies per owner or per profile, and read the totals with model_spend_summary.

Models & providers guide ↗
agent@chatgpt:~$ call mcp.agent_spawn({
  "workspaceId": "ws_8f93e120da4c71b2e9f0",
  "profileId": "pi-default",
  "idempotencyKey": "fix_auth_01",
  "prompt": "Fix the flaky auth test"
})
→ accepted: agent_41c2e9b07d1f4a8c3b6e (generation 1)

agent@chatgpt:~$ call mcp.agent_status({
  "workspaceId": "ws_8f93e120da4c71b2e9f0",
  "agentId": "agent_41c2e9b07d1f4a8c3b6e"
})
✓ completed • summary ready • 41% of cost budget used

One Skill Library for Every Agent

Skills are folders of instructions and optional scripts. Manage them once in the dashboard and every connected client discovers them in each workspace through skills_list, skills_read, and skills_run.

LIBRARY

Versioned & reviewable

Every revision is append-only. Diff, restore, fork, and archive skills, and see which skill sets or live workspaces pin each one.

SKILL SETS

The right skills per task

Group skills into sets and let skill_suggest recommend the matching skill before an agent plans its work.

TOOLKITS

Open-source presets

Mount curated toolkits such as mattpocock/skills and obra/superpowers, or any pinned public Git repository of skills.

BUILT IN // AGENTKIT.BEST

AgentKit kits, ready to mount

Licensed AgentKit.best kits such as engineer and marketing mount read-only from a signed registry, and the ak CLI ships inside the executor. The licence token never reaches repository code.

Agent toolkits & skills guide ↗

Kits That Make Every Agent Ship Like a Team

AgentKit.best packages development and marketing workflows as skills, hooks, and specialist subagents, with the ak CLI and a desktop app to install and manage them. Cloud Harness MCP is built by the same team, so licensed kits mount read-only in every workspace and ak is already inside the executor.

Explore AgentKit.best ↗
  • ENGINEER Plan, build, test, review, ship Full-stack development skills, workflows, and specialist agents.
  • MARKETING Research, content, growth Sales, content, and growth automation for every launch.
  • APP Desktop control center Install, update, and manage licensed kits in one place.

100+ Precision Coding & Agent Tools

From file editing and symbol search to Git, GitHub, packages, knowledge, and managed coding agents — every tool typed, bounded, and owner-scoped.

symbols_search LIVE

Search LSP symbols, declarations, and definitions across TypeScript, Go, Python, and Rust.

files_apply_patch LIVE

Apply line-anchored atomic text patches with conflict detection and rollback.

grep_search LIVE

Rust-powered regex search with cross-line multiline support and gitignore respect.

shell_open & shell_io LIVE

Interactive persistent PTY shell sessions supporting full terminal interaction and ANSI signals.

tasks_run & tasks_graph LIVE

Dispatch DAG multi-stage tasks with topological barriers, artifact tracking, and timeouts.

worktrees_create LIVE

Spawn instant isolated branch worktrees allowing subagents to work without Git collisions.

git_push LIVE

Push commits through stdin-fed short-lived GitHub App tokens with force-with-lease safety.

skills_list & skills_run LIVE

Discover and execute repository-defined custom skills, automated code reviewers, and linters.

hooks_list & hooks_run LIVE

Run repository lifecycle hooks (pre-commit, post-build, security-scan) in isolated sandboxes.

deployments_run LIVE

Trigger owner-reviewed repository deployment recipes directly from AI agent context.

memories_read & write LIVE

Store and recall durable repository decisions and conventions across agent sessions.

agent_spawn LIVE

Spawn a budgeted Pi coding agent in its own isolated container against a workspace.

agent_status & logs LIVE

Read an agent's state, budgets, bounded logs, and terminal summary without blocking your session.

model_profile_create LIVE

Create and validate model profiles, verify provider connections, and review spend from your client.

Turn ChatGPT Into Your Software Factory Control Center

Connect the AI tools you already use — ChatGPT, Claude, Claude Code, Cursor, Codex, Gemini, Grok, Antigravity — to one remote harness. Plan in a chat, then clone, build, test, review, and open the pull request without leaving it.

  • ChatGPT
  • Claude
  • Claude Code
  • Cursor
  • Codex
  • Gemini
  • Grok
  • Antigravity

Honest status: it is not a fully autonomous software factory yet — but with managed agents, the gateway, and shared skills, we are getting very close.

The owner deployment has two non-interchangeable lanes: Managed OAuth at https://harness.zuey.me/mcp, where Cloudflare Access is the OAuth authorization server, and a static API-key lane at https://api.harness.zuey.me/mcp. How the OAuth lane works.

Claude Code Setup

Static API-key lane: connect via Streamable HTTP with a dashboard-managed API key. Claude Code will instantly acquire all remote execution capabilities.

  • → Full worktree & subagent task graph support
  • → Non-root execution ensures your local machine stays clean
  • → Auto-reconnect with session recovery
claude mcp add cloud-harness \
  --transport http \
  https://api.harness.zuey.me/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

Install CloudHarness in Seconds

Deploy a private single-owner server on your own Linux VPS, install the portable companion skill, or integrate agent plugins.

ℹ️ The server, operating skill, and authenticated MCP connection are separate installation steps.

1-Click Linux VPS Server (Caddy TLS)

Single-command interactive installer for Ubuntu 24.04 / Debian 12 with automatic Let's Encrypt TLS reverse proxy to loopback 127.0.0.1:3100.

  • → Generates high-entropy cryptographic keys & secret keyring
  • → Enables systemd auto-restart service
  • → Includes cloudharness CLI (status, token view/rotate, upgrade)

Runs repository installer as root. Review source on GitHub repository first.

curl -fsSL https://raw.githubusercontent.com/bestagentkits/cloud-harness-mcp/main/scripts/install.sh | sudo bash
Architecture Preview // Multi-Tenant Cloud Platform

CloudHarness HaaS (Harness as a Service)

Scale beyond single-owner servers. Explore our 3-tier Tenant Isolation Ladder — from dedicated single-tenant provider VMs in Beta to hardware-isolated Firecracker KVM MicroVMs with fail-closed security and double-entry metering in GA.

🛡️ ADR 0001 Isolation Ladder ⚡ Sub-150ms Cold Boot Target 💳 Double-Entry Ledger
Explore HaaS Architecture & Roadmap →

Hardened Single-Owner Invariants

Designed intentionally for one trusted operator or team. Arbitrary execution capability inside shared-kernel executors with strict boundary separation.

🔒 No Docker Host Socket Mounting

The API and Ingress proxy never receive Docker socket mounts or host volume binds. Docker daemon control remains strictly localized to the trusted Runner daemon.

🔑 Runner-Only GitHub App Credentials

GitHub App private keys stay inside the runner. Installation tokens are short-lived and piped over stdin to an ephemeral git helper.

🛡️ Non-Root Docker Sandboxes

Executors run as non-root UID 10001 with read-only root filesystems and memory/CPU caps. Dependency egress is the shipped default and is never a silent downgrade; choose network-none per workspace or instance-wide for full isolation.

⏱️ Automatic TTL Cleanup & Zero Residuals

Workspaces are destroyed immediately upon workspace_close or when TTL expires, leaving zero leftover state, containers, or leaked temp files.

Free Forever. MIT Licensed. Let's Build It Together.

No subscription, no seat limits, no vendor lock-in. Run it on your own VPS, read every line, and help shape where it goes next — issues, pull requests, and new skills are all welcome.

  • ✓ 100% free and self-hosted
  • ✓ MIT license, public roadmap in issues
  • ✓ Bring your own models and MCP servers
Star & Contribute on GitHub ★ Read Getting Started Guide ↗