openAVO

OpenAVO is the canonical project home for the open MetaHarness implementation of an Autonomous Variation Operator. It gives an agent room to inspect, hypothesize, edit, execute, evaluate, repair, branch, restore, and commit while the harness retains control of permissions, budgets, protected invariants, promotion, rollback, and evidence.

Open the interactive explainer

The agent proposes the next experiment. The harness decides what is allowed, what counts as evidence, and what may survive.

Most coding agents are optimized for a short sequence: receive a task, call tools, produce an answer. Difficult repository work is different. Progress may require many experiments, contradictory evidence, recovery after interruption, alternate branches, and an evaluator that the agent cannot modify or forge.

OpenAVO makes that long running process explicit and governed.

flowchart LR
    A[Inspect] --> B[Hypothesize]
    B --> C[Edit]
    C --> D[Execute]
    D --> E[Evaluate]
    E -->|Improved| F[Commit]
    E -->|Failed| G[Repair or revert]
    G --> B
    F --> H[Signed evidence]

The loop may vary its strategy. It cannot grant itself new capabilities, alter protected tests, rewrite security policy, expand its budget, or promote its own result without passing harness owned gates.

The reference runtime is published as @metaharness/avo and currently maintained in ruvnet/metaharness/packages/avo. This repository is its canonical product, documentation, evidence, and integration home.

Each accepted transition is chained:

H[t+1] = SHA256(H[t] || action[t] || observation[t] || policy[t] || workspaceDigest[t])

Denied actions still produce receipts, but never reach the environment. The structural command guard is a guardrail, not a sandbox. Untrusted workloads still require RVM, container, or equivalent process isolation.

The implementation was tested on 100 unseen SWE Bench Verified instances selected with seed 251. The task set hash was committed before solving. All three arms used the same fixed model, budgets, and official evaluator.

ship: false

The result is useful and intentionally bounded. The governed multi action loop nearly tripled verified resolution over the fixed Darwin arm, but it did not meet its own economic release threshold. The supervisor and memory arm also resolved one fewer task than AVO without the supervisor, so the current evidence supports the governed loop, not a claim that every additional control improves raw accuracy.

1. A real 205 action RVF run was terminated and restored at actions 100 and 200.
2. The rebuilt run produced identical receipts, state hash, evaluator evidence, lineage, and winner.
3. An adversarial agent attempted to mutate authoritative evaluation context.
4. Deep copied agent context and an independent evaluator prevented forged promotion.
5. Live governed repair loops were validated against OpenRouter Qwen3 8B and Cognitum low with signed receipts and auditable usage evidence.

npm install @metaharness/avo agenticow

import { GovernedVariationOperator } from "@metaharness/avo";

const operator = new GovernedVariationOperator({
  runId: crypto.randomUUID(),
  task: "Repair the repository without changing protected behavior",
  seed: {
    id: "root",
    branchId: "main",
    workspaceDigest: "sha256:current-workspace",
  },
  agent,
  environment,
  evaluators,
  knowledge,
  policy,
  approval,
  memory,
  supervisor,
  signer,
  checkpointStore,
  budget: {
    maxActions: 40,
    maxBranchActions: 20,
    maxCostUsd: 5,
    maxWallTimeMs: 900_000,
    riskBudget: 10,
  },
  invariants: {
    immutableCapabilities: ["repository:read", "repository:write", "test:run"],
    protectedPaths: [".github/**", "security/**"],
    promotionDelta: 0,
    requireSignedReceipts: true,
    requireZeroPolicyViolations: true,
  },
  runtimeVersion: "0.1.2",
  stopOnVerifiedWinner: true,
});

const result = await operator.run();

The host supplies the model backed agent, bounded repository adapter, independent evaluator, policy, budgets, protected invariants, optional RVF memory, supervisor, signer, and checkpoint store.

Use AVO when all four conditions hold:

1. The task is difficult enough to need iterative experimentation.
2. A reliable evaluator can distinguish progress from plausible output.
3. The result is valuable enough to justify roughly 2 to 10 times the model, evaluator, and wall time overhead of a fast path.
4. Recovery, auditability, and policy enforcement matter more than minimum latency.

Keep simple or weakly evaluated work on the Darwin fast path. A weak evaluator turns autonomous optimization into a Goodhart engine.

1. Interactive OpenAVO explainer
2. ADR 251: governed autonomous variation runtime
3. Reference package source
4. NVIDIA AVO ARC AGI 3 report
5. Autonomous Variation Operator paper

MIT