metaharness/docs/visual-walkthrough.md at main · ruvnet/metaharness · GitHub
Skip to content

Latest commit

 

History

History
171 lines (97 loc) · 10.5 KB

visual-walkthrough.md

File metadata and controls

171 lines (97 loc) · 10.5 KB

MetaHarness in motion

Follow the complete MetaHarness workflow: analyze a repository, generate an owned harness, connect a host, enforce policy, use memory and routing, evaluate changes, and ship a package.

← Repository overview · Quick start

MetaHarness complete animated walkthrough: 12 chapters.

12 chapters · 96 seconds · loops automatically. Open any chapter below to study one flow. With reduced motion enabled, the tour holds its opening scene; the individual chapters remain available.

These diagrams explain architecture and documented workflows. Moving particles illustrate control or data flow; they are not live telemetry, timing measurements, or benchmark results.

Chapter What it explains
01. Begin with your repository Repository analysis produces a recommendation before scaffolding.
02. Compose the agent you need The generator turns project choices into a harness you own.
03. One shared kernel Generated harnesses consume a shared Rust kernel through host adapters.
04. Bring your preferred host The same generated harness connects through distinct host adapters.
05. Give tools a policy boundary Tool permissions, approval rules, timeouts, and audit belong to policy.
06. Keep context scoped Project memory and optional field memory have different setup requirements.
07. Route against your quality bar The router selects the cheapest candidate predicted to meet the quality bar.
08. Evolve the harness Darwin evaluates harness changes behind sandbox and safety gates.
09. Make releases reviewable Validation and evidence connect generated files to a reviewable release.
10. Ship it under your name Customize, validate, then publish the package under your chosen scope.
11. Explore governed extensions AVO, field memory, and ARC experiments have separate validation boundaries.
12. Mint your first harness Create a named harness with the CLI and inspect the generated project.

01. Begin with your repository

Begin with your repository. Repository analysis produces a recommendation before scaffolding.

harness analyze-repo reads repository structure and recommends a harness. Analysis does not execute repository code. Inferred build and test commands are emitted with execution disabled until explicitly trusted and enabled.

Read more: User guide · Analyze-repo quick start.

02. Compose the agent you need

Compose the agent you need. The generator turns project choices into a harness you own.

Use the Studio or CLI wizard to select a starting template and a host. The generated project contains agents, skills, commands, tool adapters, scoped memory configuration, governance, and provenance. Trim anything your repository does not need, then customize the package identity and behavior.

Read more: Studio · User guide.

03. One shared kernel

One shared kernel. Generated harnesses consume a shared Rust kernel through host adapters.

The generator produces an owned harness. That harness consumes @metaharness/kernel, whose Rust implementation is distributed through WASM and native bindings. Host-specific behavior belongs in adapters; the kernel does not depend back on a host. The kernel supplies reusable governance, memory, routing, and witness primitives.

Read more: Architecture · Kernel boundary.

04. Bring your preferred host

Bring your preferred host. The same generated harness connects through distinct host adapters.

Choose the host integration your workflow needs. Claude Code and Codex use MCP surfaces; other hosts can use native extensions, skills, or CI configuration. Not every host supports MCP or the same policy controls. Prime Agent emits a sandbox-required runbook when a non-empty deny-list cannot be enforced by the host itself.

Read more: Host matrix · Host integration design · RVM adapter.

05. Give tools a policy boundary

Give tools a policy boundary. Tool permissions, approval rules, timeouts, and audit belong to policy.

The MCP adapter supports off, local stdio, and authenticated remote modes. Generated policy starts with restrictive defaults and exposes the permissions and limits for review. harness mcp-scan performs static checks for risky grants, missing audit or timeout settings, and other policy problems; it does not run the target tools.

Read more: MCP policy · MCP design.

06. Keep context scoped

Keep context scoped. Project memory and optional field memory have different setup requirements.

The scaffold carries a memory namespace scoped to your harness. Experimental field memory is a separate, opt-in feature with deployment requirements for storage, a compatible adapter, and an authenticated principal verifier. It does not open storage or accept shared updates until those prerequisites are satisfied. Its illustrated vector geometry is a visual metaphor.

Read more: Memory and features · Field-memory contract.

07. Route against your quality bar

Route against your quality bar. The router selects the cheapest candidate predicted to meet the quality bar.

@metaharness/router consumes query vectors and labeled evaluation examples. It predicts candidate quality and selects the cheapest model predicted to clear your configured threshold; if none does, it returns the best predicted candidate and reports whether the bar was met. The picture is illustrative and makes no universal quality or savings guarantee.

Read more: Router API and training.

08. Evolve the harness

Evolve the harness. Darwin evaluates harness changes behind sandbox and safety gates.

Darwin Mode proposes changes to the harness, tests them in a sandbox, and keeps improvements that pass its evaluation and safety gates. The model stays frozen. Generated projects expose npm run evolve; no-network, no-API-key defaults support bounded refactoring and tuning. Changes still need evidence; animation is not a benchmark.

cd my-bot
npm run evolve

Read more: Darwin source · Darwin in the README.

09. Make releases reviewable

Make releases reviewable. Validation and evidence connect generated files to a reviewable release.

Generated provenance records what was produced. Doctor and validation commands help keep a customized harness healthy. The repository documents CI gates for kernel tests, generator checks, security, and deterministic signed witness manifests. Consult those gates and current CI for evidence rather than treating an animated status as a test result.

Read more: Quality gates · Witness and provenance.

10. Ship it under your name

Ship it under your name. Customize, validate, then publish the package under your chosen scope.

Rename and configure the generated project, keep the agents and tools your repository needs, validate it, and publish under your own package name or organization scope. Publishing is an explicit maintainer action. Consumers then use the versioned CLI you own; the generator does not silently publish a package for you.

Read more: Customize and publish · User guide.

11. Explore governed extensions

Explore governed extensions. AVO, field memory, and ARC experiments have separate validation boundaries.

AVO adds governed variation with budgets, rollback, quarantine, and replay receipts. ARC and field-memory packages remain experimental and have their own deployment and evidence requirements. The stronger AVO-class claim is gated on its preregistered unseen-task evaluation; ARC results are not claim-eligible until the documented controlled-ablation gate passes. Weight-EFT is a separate, optional model-tuning path, distinct from frozen-model Darwin evolution.

Read more: AVO runtime · AVO release claim gate · ARC evidence gate.

12. Mint your first harness

Mint your first harness. Create a named harness with the CLI and inspect the generated project.

Run the wizard for guided choices, or use a template and host explicitly. The example below generates my-bot for Claude Code; select --host codex for Codex. The Studio provides a browser workflow, and the user guide explains the generated files and commands.

npx metaharness my-bot --template vertical:coding --host claude-code
cd my-bot
npx . --help

Read more: User guide · Studio.

Start with MetaHarness

Open the Studio · Read the user guide · Explore MetaHarness

npx metaharness --wizard

About the animations

Self-contained SVGs with native vector motion, no scripts, remote images, or external fonts. The layout uses a compact 16:9 canvas; all important content also appears as selectable text. The visual language follows RuVector: a near-black field, pale cyan geometry, mint signals, and orange trajectories. Geometric projections are visual metaphors, not claims about the underlying implementation.

The source storyboard and regeneration instructions are in visuals/README.md.