v0.7 · Apache-2.0 · Rust · Claude Code / Codex / Antigravity

A harness that ships features — and learns from every failure.

epic-harness folds thirty agent commands into three, enforces TDD and security while your agent works, and after every session turns what broke into new skills it loads next time.

Install in one command View source
runs autonomously pauses to ask you — only when unclear, or after 3 failed checks

The problem

Frontier agents still thrash. Nobody is watching.

Left alone, an agent repeats the same error, edits, breaks the build, edits again, and takes shortcuts on auth code. You find out at review time. epic-harness watches every tool call from the inside and intervenes while it matters.

Same error, four times

Nothing tracks failure history, so the agent re-enters loops it already escaped — and pays for them again tomorrow.

Fix, break, repeat

An edit "succeeds", the build fails, another edit. Without edit↔error cycle detection, thrashing looks like progress.

Security by mood

Auth and DB code gets written however the model feels that session. No checklist, no threat model, no gate before the PR.

The harness answer: six invisible hooks run on every session — guard blocks destructive commands before they execute, polish formats and typechecks every edit, observe scores every tool call on three axes. And when the session ends, the evolve loop turns the failure record into skills.

Measured, not claimed

What the eval suite shows

Run with benchmarks/ab/run_director.py against the bare model — methodology and raw data are in the repo.

50/50
destructive commands intercepted by the guard hook
0%
false positives on normal commands like cargo test, pytest
−36%
turns on a concurrency race bug — root-cause first, not trial-and-error
13→11
turns on a multi-file feature — TDD and verify gates kill regression loops

Ring 0 Guard 50 · Golden Set task4/task5 · SWE-bench Verified B1/B2/B4 · full reports in benchmarks/ab/

One command to a PR

/orbit runs the whole pipeline. You approve at the gates.

Clear requirement? It goes straight through. Ambiguous? It stops and asks. Three failed checks? It pauses for your call. Everything else is hands-off until the pull request.

spec

Requirements locked

Numbered requirements + acceptance criteria. Council of 4 voices when the design is contentious.

go

Built by TDD

Auto-planned tasks, test-first subagents, parallel execution, criteria verified.

check

Reviewed three ways

Parallel code review + security audit + tests. FAIL retries up to 3×, then asks you.

ship

PR + CI

Isolated worktree test, PR with the full check report in the body, CI watched and auto-fixed.

evolve

Lessons banked

The session is analyzed automatically and new skills are seeded for next time.

■ autonomous■ your gates: mode choice (only when unclear) · 3 failed checks

Pipeline state persists as JSON after every phase — it survives context compaction. Prefer the pieces? /spec /go /check /ship still work on their own.

A real epic-harness session, end to end

a real session, unedited

Mission control

A dashboard you never had to build.

Ten live screens ship with the harness — eval scores, tool stats, the /orbit pipeline, evolved skills, hook health. It opens itself with your first session on localhost:7700. The Eval & Evolve screen shows the learning engine’s actual state: reward-hacking warnings, the seesaw registry, and what it wants to try next.

epic-harness dashboard overview The /orbit pipeline screen of the dashboard

Architecture

Four rings, one harness

your agent every session Ring 0 · hooks Ring 1 · 3 commands Ring 2 · 25 auto skills Ring 3 · evolve
  • RING 0

    Autopilot hooks — invisible

    resume restores context and detects your stack. guard blocks force-push-to-main, rm -rf /, DROP prod. polish auto-formats (Biome/Prettier/ruff/gofmt) and typechecks. observe logs every tool call.

  • RING 1

    Three commands you actually type

    /orbit spec→PR in one shot · /team design and sync org-level agent teams · /evolve inspect the learning loop.

  • RING 2

    Twenty-five skills that fire themselves

    tdd on new features, debug on test failures, secure when auth/DB code is touched, perf on hot loops, simplify past 200 lines, threat-model / vuln-scan / triage as a full security pipeline — you never invoke them.

  • RING 3

    The loop that makes it yours

    Failures become seeded skills. Every skill is A/B-tested against a holdout arm; proven ones stay. Details below.

Ring 3 — the part nobody else has

It studies your failures, then studies its own fixes

Every session is scored on tool success, output quality, and execution cost. Four pattern detectors — repeated errors, fix-then-break cycles, debug loops, thrashing — trigger skill proposals graduated by severity.

Observe3-axis scoring on every tool call, per-session JSONL
Analyzeper-tool / per-filetype scores + failure patterns
Proposegraduated by score — skip, moderate, or full rewrite
Gateformat + dedup + cap 10, promoted after 3 sessions
Reloadnext session loads evolved skills automatically

The loop defends itself: a seesaw gate blocks seeding when a solved task regresses, a critic rejects reward-hacking edits that trade quality for cost, variant isolation forks a sibling instead of overwriting, and 3 sessions without 5% improvement rolls back to the best checkpoint. Each skill's real effectiveness is measured against a holdout arm — evolve history shows the With / Without delta. Cold-start presets for Rust, Go, Python, and TypeScript mean day one is already useful.

Usage

Install once. It shows up in your next session.

CLAUDE CODE — plugin (recommended)

/plugin marketplace add epicsagas/plugins
/plugin install epic@epicsagas

CODEX CLI

codex plugin marketplace add epicsagas/plugins

ANTIGRAVITY

agy plugin install https://github.com/epicsagas/epic-harness
agy plugin enable epic

BINARY ONLY — HOMEBREW / CARGO / CURL

brew install epicsagas/tap/epic-harness
# or
cargo binstall epic-harness
# or
curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/epicsagas/epic-harness/releases/latest/download/install.sh | sh

VERIFY

epic --version
ls ~/.harness/          # data dir, auto-created on first session

No setup wizard. The binary self-seeds ~/.harness/config.toml on first run; the web dashboard (10 live screens) opens with your first session. Stack presets apply themselves on day one. Telemetry is anonymous and off-able: epic-harness telemetry off.

Skills that trigger on context — not on you

tddnew feature or bug fix — red→green→refactor enforced
debugtest failure or runtime error — root cause first
secureauth / DB / API / secrets code touched
perfloops, queries, rendering, batch ops
simplifyfile over 200 lines or high complexity
verifybefore any "done" claim — build, test, lint pass
councilambiguous architecture call — 4 voices, then one answer
threat-model / vuln-scan / triagethree-stage security assessment pipeline

Before you ask

Details that matter

Does it work outside Claude Code?

Yes — Codex CLI (full hooks) and Antigravity (partial: no PreToolUse, so guard/polish are unavailable) share the same ~/.harness/ data. The binary also runs standalone with brew / cargo / curl.

What data leaves my machine?

Anonymous usage telemetry only — command name, duration, outcome, failure class, OS, and a random install id. Never source code, file contents, paths, env vars, or secrets. Turn it off any time: epic-harness telemetry off.

Can an evolved skill make things worse?

That's what the gates are for: format + dedup + a 10-skill cap, holdout A/B measurement, seesaw protection against forgetting, critic rejection of reward-hacking edits, and automatic rollback after 3 stagnant sessions. Static core skills always outrank evolved ones.

Can the guard block my team's risky commands?

Add project rules to .harness/guard-rules.yaml — block or warn patterns with messages — and commit it so the whole team shares them. Hook intensity is configurable: minimal / standard / strict profiles.

Stop re-explaining your agent's mistakes to it.

Install the plugin, run one command, and let the harness keep the lessons.

Install epic-harness Read the 5-minute quickstart