agent-harness-generator

The meta-harness for AI agents — a harness that builds other harnesses.

Like ruflo is the meta-harness for Claude, this is the meta-harness for AI agents themselves: a system whose job is to produce focused, vertical, branded agent harnesses that run on any host. Pick primitives, pick content, supply identity → ship a npm-publishable harness with your own npx <name> CLI, MCP server, memory, learning loop, and witness-signed releases.

One line: A meta-harness — a marketplace plugin + CLI that scaffolds your own focused, vertical AI agent harnesses with their own npx <name> command, MCP server, memory, learning loop, and brand — that run unchanged on Claude Code, Codex, pi.dev, Hermes, OpenClaw, and RVM.

What's a meta-harness? A harness is a runtime that orchestrates AI agents (memory + routing + hooks + MCP + claims). A meta-harness is the level above: a harness whose product is OTHER harnesses. agent-harness-generator emits self-contained, npm-publishable harnesses you OWN — same kernel, your branding, your agents, your marketplace presence. The kernel updates flow to your harness via @ruflo/kernel npm peer; the content stays yours.

One paragraph: Ruflo bundles primitives (MCP server, hooks, memory bridge, swarm coordinator, intelligence pipeline, claims, routing) WITH opinionated content (60+ agents, 30+ skills, 33 plugins). agent-harness-generator factors those apart. You pick the primitives, pick the content, supply a name + brand, and out comes a brand-new npm-publishable harness with its own CLI, MCP registration, memory namespace, and marketplace identity — running on the host of your choice.

Status

Scaffold landed. The Rust workspace, npm workspace, CI matrix, and GCP-gated publish pipeline are committed. Implementation work continues on a /loop-driven cadence. The 17 ADRs in docs/adrs/ define the design.

Layer	Status	Where
Kernel design	Designed	ADR-002, ADR-002a
Rust crate skeleton (7 subsystems)	Scaffolded	`crates/kernel/`
WASM bindings (wasm-bindgen)	Scaffolded	`crates/kernel-wasm/`
NAPI-RS bindings	Scaffolded	`crates/kernel-napi/`
`@ruflo/kernel` runtime resolver	Scaffolded	`packages/kernel-js/`
`create-agent-harness` CLI	Stub	`packages/create-agent-harness/`
CI (Rust + wasm + Node matrix)	Wired	`.github/workflows/ci.yml`
Publish pipeline (GCP Workload Identity Federation)	Wired	`.github/workflows/publish.yml`
Security (cargo-audit, cargo-deny, npm-audit, CodeQL)	Wired	`.github/workflows/security.yml`
Smoke test contract	Wired	`scripts/smoke.mjs`
Host adapters (Claude Code / Codex / pi.dev / Hermes)	Iter 2+	ADR-004
Templates + composer	Iter 2+	ADR-003

Architecture in 60 seconds — the meta-harness pattern

   You                                  <- harness AUTHOR (uses the meta-harness)
       |
       v
   agent-harness-generator              <- THE META-HARNESS
   (this repo: scaffolds, signs, publishes harnesses)
       |
       v
   Your harness (npm package)           <- THE HARNESS YOU SHIP
       |
       v
   Your users
       |
       v
   npx <your-name>                      <- Identity (rename + brand)
       |
       v
   <your-harness>                       <- Content (your agents/skills/plugins/prompts)
       |
       v
   @ruflo/kernel                        <- Kernel (shared primitives, Rust + WASM + NAPI-RS)
       |
       v
   Host adapter                         <- Per-host abstraction
   (Claude Code / Codex / pi.dev / Hermes / OpenClaw / RVM)
       |
       v
   LLM providers

Read top-down: you (the harness author) operate the meta-harness. The meta-harness produces your harness. Your harness is what users install. They never see the meta-harness layer — only the brand and CLI you ship.

The kernel is Rust source code compiled to two targets: WebAssembly (primary, cross-platform) and per-platform native binaries via NAPI-RS (escape hatch for hot Node paths). At load time, @ruflo/kernel prefers the native package for the current platform and falls back to wasm.

Working precedent: @ruvector/[email protected] — 55 KB wasm-opt'd module shipping today through exactly this Rust → wasm-pack → npm pipeline.

Host support

Host	Integration shape	Notes
Claude Code	MCP server + 5-handler-type hooks + 3-scope settings	Ruflo-native target; richest hook surface
OpenAI Codex	MCP via `~/.codex/config.toml` `[mcp_servers.*]` tables	TOML not JSON; no first-class hooks
pi.dev	Pi extension (TypeScript via `pi install npm:...`)	No MCP by design — adapter uses `pi.registerTool()`
Hermes Agent	MCP-supported runtime (`optional-mcps/`)	Adapter scrubs `<think>` + stray `<tool_call>` per issue #741
OpenClaw	MCP via `~/.openclaw/openclaw.json` + workspace skills	Personal AI assistant gateway with built-in multi-platform messaging (WhatsApp/Telegram/Slack/Discord)
RVM	Bare-metal microhypervisor (AArch64) with capability tokens + hash-chained witness	Hardware-isolated deployment for federated / multi-tenant / untrusted-peer scenarios (ADR-018)

See ADR-004 — Host integration model.

Quality gates

Concern	Where	What it does
CI	`ci.yml`	Rust 3-platform matrix (fmt + clippy `-D warnings` + test + doc), wasm build + `wasm-tools validate` + 500 KB size budget, Node 20/22 × 3-platform tests
Publish gate	`publish.yml`	GCP Workload Identity Federation auth → Secret Manager fetches `NPM_TOKEN` → smoke test → `npm publish --provenance` (SLSA L2)
Security	`security.yml`	cargo-audit, cargo-deny, npm-audit, CodeQL, weekly cron
Smoke	`smoke.mjs`	Kernel loads, `kernelInfo().version` matches `package.json`, `mcpValidate` accepts/rejects correctly
Provenance	ADR-011	Ed25519-signed witness manifest, byte-deterministic across CI runners (wasm enables this)

Quick start (developers)

git clone https://github.com/ruvnet/agent-harness-generator
cd agent-harness-generator

# Rust workspace
cargo test --workspace
cargo clippy --workspace --all-targets -- -D warnings

# WASM build
npm run build:wasm

# TypeScript + smoke
npm install
npm run build
npm run smoke

See CONTRIBUTING.md for the full developer workflow.

Read the design (17 ADRs + INDEX)

Start here: docs/adrs/INDEX.md

Highlights:

ADR-001 Goals & non-goals — what this is and isn't
ADR-002 Kernel boundary — Rust + WASM + NAPI-RS
ADR-002a Publishing pipeline — Cargo workspace + wasm-pack + napi build
ADR-003 Generator architecture — create-vite-style templates + AST-aware rename
ADR-004 Host integration — adapter contract per host
ADR-006 Memory + learning — @ruvector/[email protected] integration
ADR-009 Anti-slop — derived trust tiers
ADR-011 Witness + provenance — signed manifests

Related projects

ruflo — the meta-harness this generator factors apart
ruvector — vector + agentic database (memory backend)
@ruvector/emergent-time — memory-decay clock the kernel uses
NAPI-RS — Rust → Node bindings used for the native target

License

MIT — see LICENSE.

Keywords: agent harness, agent harness generator, AI agent scaffolding, MCP server, Claude Code plugin, Codex plugin, pi.dev extension, hermes agent, multi-agent framework, agentic AI, agentic workflow, autonomous agents, agent orchestration, vertical AI harness, agent CLI generator, npm create agent, npx scaffold, Rust WASM kernel, NAPI-RS, wasm-bindgen, wasm-pack, agent memory, ReasoningBank, HNSW, emergent time, agent provenance, witness manifest, plugin marketplace, IPFS registry, drift detection, anti-slop, TDD, self-evolving agent, federated agents, swarm intelligence, GCP Workload Identity Federation, Secret Manager, SLSA provenance, npm provenance