autoharness

<h1 align="center">AutoHarness</h1> <p align="center"><strong>Self-Learning Skills for Claude Code</strong></p> <p align="center"> <img src="https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Ftigerless-labs%2Fautoharness%2Fmain%2F.claude-plugin%2Fplugin.json&query=%24.version&label=release&prefix=v&color=brightgreen" alt="release" /> <img src="https://img.shields.io/badge/python-3.11%2B-blue.svg" alt="python" /> <img src="https://img.shields.io/badge/platform-Linux%20%7C%20macOS-lightgrey.svg" alt="platform" /> <img src="https://img.shields.io/badge/license-MIT-yellow.svg" alt="license MIT" /> </p>

autoharness is a self-learning skill layer for Claude Code. It learns skills from your real sessions, merges same-scenario ones instead of stacking near-duplicates, updates them in use, and prunes any that stop getting used — so the layer stays clean on its own, touching only the skills it wrote itself.

Same model, different harness — 42% → 78% on CORE-Bench (HAL). The harness does much of the work (swyx's Big Model vs Big Harness), yet it's still rebuilt by hand every model generation. autoharness bets one slice of it — the skill layer — can maintain itself.

| | | |---|---| | Learns from real work | Each episode is distilled into a skill from the session you were already having — no separate data-collection or replay loop. It fires on its own once a session has done enough work; /learn distills on demand when you want a lesson kept now. | | Groups, doesn't just pile up | A new episode doesn't always add a skill — the reflector compares it against what's there and folds same-scenario skills into one, so the layer consolidates by category instead of accreting near-duplicates. A fold records which skill absorbed which, so a merge is never mistaken for a death. | | Keeps its own library in view | Every session opens with a grouped index of the skills it wrote, so recall doesn't depend on the host happening to surface them. The host's native recall is left exactly as it was; the index is added on top. | | Validated in use, not on a benchmark | A skill survives by being adhered to in later turns (loads over the requests it was available for), not a held-out score. No oracle on the active path, and no tokens spent on a dedicated eval. | | Only its own skills | Touches only the skills it generated through this plugin — everything else, whether you wrote it or installed it, is left completely alone. | | Evidence kept for later | Every create/update logs its scenario and decision to a per-skill ledger — the raw material to build a benchmark from real usage if you ever want one. |

Install

Requires python3 on your PATH — autoharness runs entirely as Python (zero third-party dependencies); its hooks and MCP server won't fire without it.

Type these in the Claude Code input box.

/plugin marketplace add tigerless-labs/autoharness
/plugin install autoharness@autoharness

Then run /reload-plugins (or restart Claude Code).

Zero config. It now watches your sessions and lands learned skills into .claude/skills/ in the background. Cadence and lifecycle thresholds are tunable — see Configuration.

Nothing to invoke, but one entry point exists when you want it: /learn distills the session you're in right now — say it after working something out and the lesson goes through the same proposal-and-validation chain the background pass uses.

Update

Update from a terminal — refresh the catalog, then update with the full plugin@marketplace id, then restart:

claude plugin marketplace update autoharness       
claude plugin update autoharness@autoharness

Then restart Claude Code to apply — a version bump is a fresh cached copy, not a hot reload.

The refresh is first on purpose: without it, update checks a stale local catalog and may report already at the latest version when a newer release actually shipped.

Third-party marketplaces have auto-update off by default. To make future releases hands-off, enable it once: /plugin → Marketplaces → autoharness → Enable auto-update. The installed copy is cached by the version in plugin.json; a release reaches users only when that field is bumped.

Uninstall

claude plugin uninstall autoharness@autoharness     
claude plugin marketplace remove autoharness       

Uninstalling only stops it from running — the skills it landed and its own state live outside the plugin and stay on disk. To clear those too, delete its state dir (~/.claude/autoharness/ global, <repo>/.claude/autoharness/ per project) and the self-authored skills under .claude/skills/ (each carries a self-authored ledger marker, so they're easy to tell from yours). Your own skills are never touched.

Configuration

Every knob is an AUTOHARNESS_* environment variable with a built-in default — nothing to configure unless you want to change the pace.

Cadence — when it learns

| Variable | Default | What it does | |---|---|---| | AUTOHARNESS_REFLECT_EVERY_N | 50 | Reflection cadence, counted in tool calls, not turns: every main-session tool call advances a counter, and the turn that pushes it past N ends with a background reflection. A working stretch triggers; a conversation that only talks never does. Lower = learns faster and spawns more child sessions. | | AUTOHARNESS_CONSOLIDATE_EVERY_N | 250 | Same quantum for the curator, the periodic pass that merges the library as a whole. Held well above the reflection cadence — consolidation is rarer than distillation. | | AUTOHARNESS_DIGEST_EXCHANGES | 20 | How many exchanges before the episode window are compressed into the reflector's prior-context digest (text + tool names only). Unused by the fork carrier, which replays the real conversation instead. | | AUTOHARNESS_CARRIER | bundle | What carries the reflection. bundle hands a redacted window + digest to a fresh subagent. fork resumes and forks the session that just ended, so the reflector reads the real conversation on the parent's warm cache. Stays bundle until the cache-hit measurement is in. |

Recall — what the model sees

| Variable | Default | What it does | |---|---|---| | AUTOHARNESS_INDEX_SUSPENDED | 0 | Set to 1 to stop injecting the index entirely. Everything else keeps running — the lifecycle pass, the use/view counters, the last-run summary — so this is the switch for measuring what the index is actually worth, and for anyone unwilling to spend the context on it. | | AUTOHARNESS_INDEX_DESC_MAX_CHARS | 60 | Per-line description budget in the session-start index. The index is a scan surface, not the full trigger text — raise it for longer lines, at the cost of context on every session. | | AUTOHARNESS_SKILL_DESC_MAX_CHARS | 1024 | Hard cap on a skill's own description, matching the host's documented limit; a longer one is rejected rather than silently truncated at load. | | AUTOHARNESS_SKILL_BODY_MAX_LINES | 25 | Altitude cap: a SKILL.md body over this many non-blank lines is rejected as a transcript rather than a rule. Backing detail belongs in the skill's references/. |

Lifecycle — what survives

| Variable | Default | What it does | |---|---|---| | AUTOHARNESS_MATURITY_PROJECT | 100 | Probation gate, project layer: after this many requests have arrived in its layer since a skill landed, it faces graduation review. Until then it's recalled as usual but can't be archived. | | AUTOHARNESS_MATURITY_GLOBAL | 300 | Same gate for the global layer — higher because a global skill loads in every project. | | AUTOHARNESS_CAPACITY_PROJECT | 50 | Cap on mature skills in the project layer. It is also what bounds the session-start index: one line per live skill, so the index can never exceed the two caps combined. For graduates, capacity contention is the only death: nothing is archived until the mature pool exceeds this, then the lowest usage rates go first. | | AUTOHARNESS_CAPACITY_GLOBAL | 20 | Same cap for the global layer — smaller because its blast radius is every project. | | AUTOHARNESS_GRADUATION_SUSPENDED | 0 | Set to 1 to park graduation review entirely, so nothing is archived for going unused. Meant for when you have reason to doubt the recall surface: archiving on zero use would then be punishing skills for never having been offered. Capacity contention still applies. | | AUTOHARNESS_SNAPSHOT_KEEP | 5 | How many pre-run snapshots of each skill tree the curator keeps before merging. A merge is the one operation a single atomic rename can't undo. |

Set them in the environment Claude Code launches with — either the shell (export AUTOHARNESS_REFLECT_EVERY_N=10) or the env map in .claude/settings.json:

{ "env": { "AUTOHARNESS_REFLECT_EVERY_N": "10" } }

Hooks read the environment on every event, so a change applies from the next session. The defaults are deliberate placeholders pending empirical calibration (tracked under experiments/); byte caps on captured windows and staged files are fixed constants, not env knobs.

How it works

A learning pipeline runs beside the host. Skills are plain native files, recalled by the host's own name-and-description mechanism as if a human had written them — that path is left untouched. On top of it, each session opens with an index of the skills autoharness wrote, so whether its own library gets offered is a property of this plugin rather than a hope about host behavior.

<p align="center"><img src="docs/assets/pipeline.svg" alt="autoharness pipeline: host → CAP → REF → promoter → .claude/skills → host, with the curator feeding the promoter, IDX injecting the index at session start, and MNG and LED beside" width="760" /></p>

_{Diagram source: docs/assets/pipeline.mmd — re-render to pipeline.svg after editing.}

| Component | Role | |---|---| | CAP · capture | Hook-driven dumb pipe: grabs each turn (user input, agent output, tool I/O), redacts at egress, points back at the host log instead of copying it. It also holds the trigger, which is deterministic and counts one thing — tool calls. The turn that crosses the threshold ends with a reflection; nothing about the content is judged here. | | REF · reflect | Reads the episode, compares it against the existing skill index, and decides add / merge / patch / drop a support file / delete — emitting an intent (body, delta, or path, plus reason and evidence). Where a new lesson contradicts an older skill, it must rewrite the stale one in the same run rather than leave the library arguing with itself. Proposes only; it has no write tools, and a fork carrier's inherited ones are denied at the hook. | | promoter · validate·store | The only writer. Lints the intent in memory (safety, structure, ledger, completeness, self-authored-only) and on pass does an atomic rename into the live skill directory. A new skill's description has to carry its trigger early enough to survive the index's truncation — a cue that lands past the cut leaves the skill as half a sentence on the very surface meant to recall it. A fold must name the skill that absorbed the deleted one, and the umbrella has to be a live skill autoharness manages — an invented name fails the whole intent rather than losing the content. Each run leaves an account of what landed and what was rejected. | | IDX · surface | Builds the session-start index: the skills autoharness wrote, grouped by category, one truncated description per line, tagged by layer. Archived and hand-written skills are excluded, an empty library injects nothing, and the previous run's landed/rejected line rides along — so a rejected proposal is visible instead of silent. | | MNG · lifecycle | Daemon-free: recomputed lazily at session start, once per session. Ranks sym