run-harness-task

Executes full-rigor task specs through a locked multi-agent verification pipeline.

Updated Jul 23, 2026
One-click install
npx skills add https://github.com/MadhavMareddy/AgentMarvel --skill run-harness-task-madhavmareddy
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: run-harness-task
Source: https://github.com/MadhavMareddy/AgentMarvel/tree/main/harness/framework/skills/run-harness-task
Command: npx skills add https://github.com/MadhavMareddy/AgentMarvel --skill run-harness-task-madhavmareddy

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? Running a complex coding task with AI agents often means trusting the model's own claims of success. This Skill removes that trust requirement by orchestrating a full agent pipeline where tests are authored blind, cryptographically locked, and judged by an independent verifier — so a passing result is backed by tamper-evident evidence, not model confidence. ## Core Features & Use Cases - Locked verification pipeline: Coordinates researcher, planner, architect, verifier-author, executor, verifier-judge, security-auditor, and observer agents in a fixed sequence with a bounded 3-attempt retry loop. - Tamper-evident test integrity: Hashes tests with sha256, locks them at the filesystem level, ties them to a scope-guard hook via .harness/run.json, and brackets the judge step with before/after fingerprints to detect tampering. - Workflow-aware routing: Resolves frozen workflow profiles, enforces a rigor guard (quick/mid tasks are rejected to the light path), asserts the hard backbone agents are present, and optionally fans out multi-agent author/executor batches through Workflow calls. - Use Case: A developer fills a task spec with acceptance criteria for a cross-module feature, then invokes this Skill to run the full pipeline — tests are authored blind from the spec, locked, the executor implements against them, and an independent judge returns a typed PASS/FAIL/PARTIAL verdict. ## Quick Start Run the filled task spec at path/to/task-spec.json through the full locked verification pipeline using prepare-run and the run-harness-task procedure.

Frequently Asked Questions about run-harness-task

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I run a task through the locked verification pipeline?

Fill a task spec conforming to the task-spec schema, then call prepare-run with the spec path and optional profile name. It validates preconditions, writes .harness/run.json, and the pipeline runs planner, verifier-author, lock, executor, and verifier-judge in order.

How does the pipeline prevent AI agents from cheating on tests?

Tests are authored blind from the spec, hashed with sha256, locked read-only at the filesystem level, and tied to a scope-guard hook that blocks tool writes. A fingerprint bracket before and after the judge step detects any tampering and aborts the run.

Can I use this skill for quick or mid rigor tasks?

No. The rigor guard in prepare-run rejects quick or mid profiles with a wrong_path abort. Those tasks run on the light path via start-task, which never invokes this skill or its locked-test machinery.

What happens when the verifier-judge returns FAIL?

A FAIL verdict increments the attempt counter and returns to the executor step, up to 3 attempts, with tests staying locked throughout. A third failure aborts with abort_type test_failure and hands the per-attempt verdict log to a human.

Why does prepare-run fail with backbone_missing?

A rigor: full profile must contain the hard backbone agents: planner, verifier-author, executor, and verifier-judge. If any are missing, prepare-run aborts before writing run.json; add the missing agents or set rigor to quick or mid.

When does the pipeline use Workflow fan-outs instead of prose dispatch?

Only when the frozen workflow block carries run_as_workflow true, the target is Claude Code, and a batch holds 2 or more verifier-authors or executors. Single-agent batches and all sequential agents always run as prose dispatches.