autoharness
Skill10 starsChanged todayMITView on GitHub
Use at the start of any non-trivial task, even when many tools are already available, especially work that must match something real (a film scene, a design, a product, a brand, an API) and so needs references, current docs or data you have not looked at yet, or a way to check the result against them. Also use whenever you are blocked because a tool, input or know-how is missing (not because you need to think harder). Works out what a good result is and what is missing, finds and vets MCP servers and skills against the user's constraints, installs them for the task, and at the end keeps them in the project or removes them (configurable).
In this repository44 other files it gives its agents.
- llms-full.txtllms.txt
- llms.txtllms.txt
- ai-prompt-engineering-safety-reviewSkill
- ast-codemapSkill
- ast-grepSkill
- autoharnessSkill
- autonomous-backlog-driverSkill
- claude-kimi-mcp-normalizationSkill
- cli-self-updaterSkill
- code-frugalitySkill
- codemode-gatewaySkill
- codemode-typesSkill
- consequence-simulationSkill
- context-pruningSkill
- github-update-checkerSkill
- google-agents-cli-evalSkill
- google-agents-cli-scaffoldSkill
- history-searchSkill
- hook-gatingSkill
- hybrid-semantic-searchSkill
- kimi-code-agent-integrationSkill
- kimi-mcp-configurationSkill
- leann-vectorSkill
- log-summarizerSkill
- markdown-vagueSkill
- memory-reconciliationSkill
- mode-classificationSkill
- multiagent-orchestrationSkill
- output-compressionSkill
- prompt-injectionSkill
- python-anti-patternsSkill
- regression-sentinelSkill
- restart-trackingSkill
- rollback-guardSkill
- rust-call-graphSkill
- secrets-managementSkill
- security-best-practicesSkill
- session-compactorSkill
- sqlite-memorySkill
- swarm-barrierSkill
- swarm-dagSkill
- autoharnessSkill
- code-reliability-checksSkill
- skill-threat-rulesSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
15 rules. About 0 are common, 5 are distinctive, and 10 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈5
Distinctive · estimate
This author's own choices. Worth a look.
10
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 18
If the hook is installed, tools that do work stay blocked until init (light) or init and brief (full).
- Very specific: line 46
If init warns that an installed copy of this skill is out of date, tell the user the install-skill command it names.
- Very specific: line 84
Prefer local skill → curated entry → high-trust result → nothing.
- Very specific: line 147
Read what a candidate actually does (a skill's SKILL.md and scripts.
- Distinctive: line 158
Never paste secrets into commands or files: tell the user which env var to set.
- Distinctive: line 171
When stuck, ask: *would more thinking fix this, or am I missing a capability?* Not seeing the thing you must check, guessing at an API …
- Distinctive: line 190
If a component looks flawed or tests fail, change the paradigm immediately: do not micro-tweak broken abstractions or geometry in-place.
- Very specific: line 192
Only once all individual components are verified and assembled, verify the integrated base (autoharness verify run "<command>" --for B1) …
- Distinctive: line 200
Change paradigm on friction: If two rounds of review flag the same part or structural defect, stop micro-tweaking the same code in place.
- Very specific: line 231
When a check fails, fix the code, not the check.
- Distinctive: line 236
After a critic finds blocking problems, do not fix from memory what your skills do not teach: research how that part is done well and write …
- Very specific: line 260
Run an arbiter's check with check --run "<script>".
- Very specific: line 262
If the user accepts the result as it is or tells you to stop: autoharness teardown --accepted "<their words>" (it does not hold the end up …
- Very specific: line 266
Save what you learned: update each skill you created, then autoharness skill save <name> (exit 3: show name, description, warnings.
- Very specific: line 279
If the project keeps a journal (JOURNAL.md, or the journal setting), teardown waits for this task's entry: autoharness journal shows a …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
AutoHarness
You start almost bare and build the harness this task needs: references, docs, tools and a way to
check the result. The autoharness CLI does the bookkeeping (lockfiles, trust checks, teardown); you
do the thinking. Every command prints JSON with a next field: follow next, it carries the
detailed procedure for the step you are in, so never cut a command's output short. Exit code 3
means stop and ask the user. Long texts with quotes, brackets or ; (a brief, a review, a
measurement) go in a JSON file instead of the command line: --args-file <file.json> with
{"diff": "...", "worst": "minor"}. Before the brief no file can be written, so pass the JSON on
stdin: autoharness brief --args-file - <<'EOF' ... EOF (Bash) or @' ... '@ | autoharness
brief --args-file - (PowerShell).
If the hook is installed, tools that do work stay blocked until init (light) or init and brief
(full). Reading files stays open. .autoharness/ holds the task's records: only autoharness
commands write there (the records are sealed, and teardown refuses an edited one). If the hook
stops the end of your turn while your task is open, finish it, or say you are waiting on the
user and end the turn again. Skip the harness only when the user explicitly said so:
autoharness waive <session id> --reason "<their words>", then tell them.
A task belongs to the agent session that started it. If another session's task is active, you are
told about it and stay blocked: tell the user; only if they want you to carry it on (or that
session is gone), autoharness claim <your session id> --reason "<their words>".
1. Start at the right level
autoharness --agent cursor init "<the user's task, verbatim>" --mode light|full|reviewed|autolight: a chore that needs no capability (a typo, a git commit). No search, no brief: do the work, verify it,teardown. A task that needs any capability of the catalog (an API, a browser, tests, debugging, an image to match) is not a chore:initraises it to full.full(default): something the result must match or a way to check it is missing. Search, brief, vet, install.reviewed: full, and an independent critic must pass the result before teardown.auto: full when the task text matches a catalog capability, else light. Keyword matching misses both ways, so prefer choosing yourself.
Raise a running task instead of starting over: autoharness mode full when a capability gap
appears, autoharness mode reviewed when the result turns out to need an independent check.
If init warns that an installed copy of this skill is out of date, tell the user the
install-skill command it names.
In full mode, answer in writing before listing tools:
- What does a good result look like, and how will I tell? A quality bar and a check, not "it renders".
- What input is missing? The original the result must match, not someone's version of it (the film still, the product photo, the API's actual response, sample data), not a description of it. Working from memory when the real thing can be looked up is a capability gap, often the biggest. Get it first.
- What are the user's constraints? Verbatim ("no new dependencies", "must run offline").
- What interface does the task name but leave open? A function, command, file format or API
that something else will call or read, without its exact form (argument order, names, types,
output layout). The words the task does use are clues (it says "domain": take a domain, not
your own
lower/upper). Look for a real example first (docs, the usual package, callers in the code); without one, accept the common forms of the call and write the assumption into--inputs, so the critic checks it. - What does the person who asked expect where the task leaves a choice open? A requirement is
what they want, and they cannot always be asked. For each open choice (a format, a value or a
formula, what a field holds) pick what they would take for granted on first look: the plain,
simple form, where what they see is what is there, nothing they did not ask for, clean to look
at. A tool's or skill's advice does not decide it for you. Record it with
--expects.
Then list capabilities: capability — why — how I will verify it works. Pick the smallest set that lets you verify the result, not only produce it. Missing input and know-how often need no install at all (web search, a browser, a headless render you already have).
2. Discover (full)
init already searched: read every entry in discovered, and reuse a matching recipe
(autoharness recipe show <name>, score above ~0.3). rejected_before names candidates earlier
tasks skipped or removed, with why: pass over them unless the reason does not apply. Where that falls short:
autoharness need <capability> --reason "<why>" # curated + your saved local skills
autoharness search mcp|skill "<query>" # MCP registry, skills.shPrefer local skill → curated entry → high-trust result → nothing. Install only what beats the
tools you have: a CLI (gh, psql, xerj) needs no MCP server. A skill is know-how, not a tool: when you
have to see and operate something live (a page, an app), step by step, cover it with an MCP server
(brief asks for one); a script written blind does not show you what is on screen.
Prepare like an engineer, not head-on. Building an aircraft takes aerodynamics, materials,
strength, control theory; every non-trivial task likewise splits into areas of know-how. List them
(--domains), and for each ask: what do I actually know, what is known out there (skills, servers,
docs, worked examples, algorithms), how will I test the hypothesis? Search each area
(autoharness search skill|mcp "<query>", autoharness need), take what fits, and where nothing
fits create the skill yourself from what you read (--gaps "create ..."), filled before the first
result. "I know how" is not a cover: what you know goes into that skill.
Research the method before you build. Someone has usually solved this kind of task before:
search the web, the field's docs, papers, repos and tutorials for how it is done well (the
algorithm, the workflow, the known pitfalls), read the best two or three sources, and write the
steps down. This is deep research, not a single query: it is the difference between doing the
work from memory and doing it the way it is done well. The steps go into --method; reusable
know-how goes into a skill (--gaps "create ...").
3. Brief (full)
autoharness brief --goal "<quality bar>" --inputs "<missing inputs, how you get them>" \
--expects "<open choice>: <pick> - <why they would expect it>; ... (or none: <why>)" \
--domains "<area>: skill|mcp|create <name> (searched: <query>); ..." \
--method "<technique or steps>: <url>; ...; searched: <queries>" \
--constraints "<verbatim>" --verify "<checks, against what>" \
--candidates "<name>: take|skip, why; ...; searched: <queries>" \
--gaps "create <skill-name>: <capability>; ..." # or "none: <why tools at hand cover it>" \
--components "<name>: <what it does / how to verify alone>; ..." # decompose into 2-4 isolated subcomponents (or none)
# --fidelity "<level to judge at>" (required for work judged by eye: "stylised poster, not photographic")
# optional: --review critic|pair (pair: + a code-quality reviewer)
# --techniques "<technique: principle; ...>" (domain-level professional craftsmanship techniques)
# --preserve "<existing behaviour that must keep working>"Number the goal's parts (1 ...; 2 ...): they become brief items B1, B2, ... (and C1, C2, ... for
--components, P1, ... for --preserve), which checks and the critic report on one by one.
Give a verdict for every plausible candidate. Show the user the brief in a few lines.
For browser, API (your own, or a third-party one: api-client), logs or database checks, autoharness verify guide <kind> has a template:
pass --verify-template <kind> instead of --verify. Visual work needs real image references
(.png, .jpg, etc., never text descriptions or notes), at least two results and a critic before teardown;
brief lists what this task owes.
No fitting skill for real know-how? Create it (--gaps "create ..."):
autoharness skill new <name> --description "<when to use>", fill When to use / Steps / How to
verify from what you found (no absolute paths, secrets or people's names) before producing the
result, follow it, and update it as you learn. Values you measured in this project (a threshold, a
mapping, a colour) go under "Facts found here", apart from the procedure: the next task re-checks
them. Teardown refuses while a planned skill is missing or unfilled. Then check it helps:
autoharness skill test <name> --task "<a realistic request>" (1-3 tasks) has fresh subagents do
each task with and without it, --judge compares them blind, --answer-file records who won.
4. Vet and install
autoharness inspect mcp <name>
autoharness add mcp <name> | autoharness add skill <owner/repo@skill>
autoharness decision mcp|skill <name> select|skip --reason "..."- Read what a candidate actually does (a skill's SKILL.md and scripts;
inspectfor a server) and check it against the constraints. A skill whose main content breaks one is no candidate; if you find out after installing,autoharness removeit and say so. vet_required: you do not judge the fit yourself.autoharness vet mcp|skill <name>, give its prompt unchanged to a fresh subagent, save the answer unedited to a file, record it with--answer-file <file>. No subagents at hand:autoharness vet mcp|skill <name> --run cursor|agy|claude|codex|kimistarts the reviewer and records its answer. Onbreaks, pick another.approval_required(exit 3): show the user name, trust score, reasons, needed secrets and anyegressreason in one message;--approveonly after a clear yes, never on your own.rejected: dangerous patterns found; pick another (--forceonly if the user insists after reading the findings).- Never paste secrets into commands or files: tell the user which env var to set.
- A low-trust skill that brings little is worse than none: write down what you know instead.
already_installed: an earlier task kept it; use it.via: gateway: works now, use Code Mode (harness_search,harness_execute) orharness_tools/harness_call. Otherwise the server is in.cursor/mcp.json: tell the user to restart Cursor (or refresh in Cursor Settings > MCP) so it picks up the new server, and continue what does not depend on it. Ifaddsuggestsautoharness gateway install, offer it once (--userputs it in your own config, for every project): later servers then need no restart.
Smoke-test each new capability with one cheap call before relying on it; if it fails,
remove it and try the next. Do not debug a third-party tool for long.
5. Execute
When stuck, ask: would more thinking fix this, or am I missing a capability? Not seeing the
thing you must check, guessing at an API whose docs you have not read, or drawing something
you have not looked at are gaps: autoharness need <capability> --reason "<what blocked me>"
(after mode full in a light task), then resume.
A browser tool that refuses file:// (Playwright MCP does) opens a local page or file over
http://localhost instead: serve the folder (python -m http.server 8000) in the background.
Matching a reference (an API's response, a sample file, a layout, a picture, the old behaviour)?
Take its facts from the reference itself with a tool, not from memory: field names and values,
sizes, positions, timings, the exact output. For codebases, avoid burning tokens reading whole files or searching blind with grep: extract exact definitions, signatures, and file:line coordinates with AST tools (xerj def <symbol>, xerj search -k 3 or codebase MCP servers). Save them to a file and record it before the first
result (autoharness evidence add <file> --kind facts); the critic checks the result against them.
Decompose, don't monolith. Never try to solve or generate an entire complex scene, architecture or multi-component system in a single unverified pass. Break it into isolated subcomponents (for a picture: focal subject, secondary figure, perspective environment, atmosphere/lighting layers; for a system: data layer, protocol, state engine). Build and verify each subcomponent progressively before full assembly.
Start small and build progressively.
- Select the smallest, most definitive isolated subcomponent.
- Build it in isolation (e.g.
officer_k.svg,auth_token.py). - Visually inspect or test it alone. Record it with
autoharness evidence add <file> --kind component --for C1. - If a component looks flawed or tests fail, change the paradigm immediately: do not micro-tweak broken abstractions or geometry in-place. Pivot to a different representation, isolate the failure, and rebuild.
- Programmatic assembly, no manual copy-paste duplication. Assemble verified components into the integrated system using modular imports, composition functions, or dedicated build pipelines (
import,<use xlink:href="...">, modular templates). Avoid retyping or copy-pasting monolithic string blobs where regressions and stale geometry hide. - Only once all individual components are verified and assembled, verify the integrated base (
autoharness verify run "<command>" --for B1) and record (autoharness evidence add <file> --kind result).
Resist LLM defaults and training biases. Models naturally gravitate towards symmetric 2D flat templates, generic stubs and standard boilerplate. When matching a real reference, discard default memory shortcuts: construct geometry, anatomy and architecture directly from authentic domain principles (e.g. 3/4 perspective planes, foreshortening, anatomical landmarks, structural framing).
Syntactic checks vs Semantic expertise. Programmatic tests (verify run) check formal invariants (types, schema, exit code, pixel bounds, syntax). The independent critic (autoharness critic) evaluates deep semantic fidelity, architecture, and aesthetic nuance against facts and references. A passing exit 0 test is not enough on its own: both formal checks and critic review are essential.
Visual feedback loop. In visual or layout tasks, never write hundreds of coordinate numbers blindly. Render the component to an image and inspect it with your eyes at each milestone before proceeding to the next layer.
Change paradigm on friction. If two rounds of review flag the same part or structural defect, stop micro-tweaking the same code in place. Change the underlying representation or method: isolate the failing component, test it alone, and rebuild its structure from measured reference facts.
Found work outside this task (a bug next door, a critic point beyond the brief)? Do not fix it
now and do not drop it: autoharness followup add "<what, where>". init shows open follow-ups;
close one a task settles with autoharness followup done <id> --note "...".
6. Finish
Verify against the quality bar and keep the evidence (light mode: verify, then teardown).
autoharness evidence add <file> --kind reference|facts|component|result # reference, facts, subcomponent, or whole result autoharness evidence add <file> --kind result --closeup # a close-up or part of the latest whole result autoharness verify run "<test command>" --for B1|C1|preserve # autoharness runs it: exit code decides autoharness evidence diff # code: the whole working-tree diff autoharness review --by self --diff "1 <most important>; 2 ..." --worst blocker|major|minor|none autoharness critic # prompt for an independent reviewer autoharness review --by critic --answer-file <file> autoharness critic --run cursor|agy|claude|codex|kimi # or: autoharness starts a read-only critic itselfA check must be able to fail when its item is not met. AutoHarness runs an AST Anti-Hollow Test Sentinel: checks that only verify superficial conditions (such as
os.path.exists,root.tag == 'svg',len(...) > 0, substring matching in file content, or lack of assertions) are marked ashollow_check: true. Hollow checks do not count towards satisfying brief items, and blockreview --by self --worst none. Artifacts are similarly inspected for structural complexity: an SVG with <20 elements, <4 paths, or missing gradients/composition, or stub code, is flagged as hollow and blocksteardown. A check that is a command goes throughverify run, never "I ran it and it passed": the run is tied to the code it saw and goes stale when the code changes, so run it again after your last edit. With--preservein the brief, teardown needs a passing--for preserverun. A command that cannot fail (true,echo ok,python -c "pass") is not a check and does not count. When a check fails, fix the code, not the check. If the check itself was wrong, teardown shows that it changed after it failed, so tell the user why. Command arguments and trailing flags (e.g.--for B1) are safely handled on all platforms. No subagents at hand (or the critic must be another model)?critic --run <agent>starts the reviewer itself.After a critic finds blocking problems, do not fix from memory what your skills do not teach: research how that part is done well and write it into the skill with the address of the page you took it from; with a reference, measure the parts the critic names from it and add that as facts (
--kind facts). Then build them through those measurements, not by eye. The next result is refused until a skill cites a new page and the new facts are in. The critic's words restated as rules are not research.Work in rounds: block in the base, add the result, run the critic, then compare each result side by side with the reference, fix the most important differences, repeat.
--worstis the worst still-fixable difference: blocker (fails its purpose), major (clearly wrong at a glance), minor (polish, or beyond the brief's fidelity). You are not the judge of your own work: give thecriticprompt unchanged to a fresh subagent, save its answer unedited and pass the file; never write that file yourself. The task may stop when the latest critic verdict isminorornone. Disagreeing is not dropping:autoharness critic --dispute "<point>"lets a fresh critic rule; record its ruling with the review,--settled "<point and ruling>". If the user rejects a critic's point, record it:autoharness ruling add "<point>" --reason "<their words>". Settled points and rulings reach every later critic in the project. Withbrief --review pair,criticgives two prompts: the critic, and a code-quality reviewer underquality. Give them to two fresh subagents in parallel, or usecritic --run. Record both in one round:review --answer-file <critic's> --quality-file <quality reviewer's>. Whenreviewanswerschange_approach,arbitrateorlimited, itsnextsays exactly what to do. In visual work each critic also compares the result blind with the best earlier one; "Went backwards" innextmeans the earlier one is closer: restore what got worse before fixing more.ask_user(exit 3, after many rounds that still block): stop, show the user itstrendand ask whether to go on or accept. Code edited after a review needs a newevidence diffand review. Run an arbiter's check withcheck --run "<script>"; where you had to check differently from its words, say so with--deviation "<what and why>"rather than adjusting it quietly. If the user accepts the result as it is or tells you to stop:autoharness teardown --accepted "<their words>"(it does not hold the end up for lessons; offer them once instead). Only their words, never your own judgment: with the hook installed,--acceptedand--forceare refused until the user has written something since the task started.- Save what you learned: update each skill you created, then
autoharness skill save <name>(exit 3: show name, description, warnings;--approveafter a yes). Reusable know-how no skill covers goes into a new one the same way. When the task had friction (a check that failed before it passed, a loop, an arbiter, rounds that went backwards, the user stepping in), teardown stops once with statuslessonsand lists them: write what failed and what fixed it into a skill, save it, then tear down again (or again without, telling the user why). A conclusion too small for a skill is an insight:autoharness lesson add "<when X, do Y, because Z>". The same conclusion from another task is merged into it, and itsconfirmedcount grows.initshows theinsightsthat bear on a task. Once teardown listsripe_insights, fold each into a skill and runlesson fold <id> --skill <name>. Alocalskill or recipe ininitmay carry arecordof earlier tasks; heed itsnote. - End:
autoharness teardown, or--save-recipe <name> --notes "<what it was good for>"(--query "skill|mcp:<query>"to re-run a search next time) when the setup was useful. Pass--keep/--removeonly when the user asked. If the project keeps a journal (JOURNAL.md, or thejournalsetting), teardown waits for this task's entry:autoharness journalshows a draft from the task's record in the journal's own form; add what was measured, where things live and what is left, put it where it says, tear down again. - Tell the user what was installed, kept and removed, any part ruled out of reach, any
teardown warning (skipped discovery or brief), follow-ups left for later, and what is left for
them (env vars, restart). Report what was checked as teardown's
checkedsays, without upgrading it: runs (current or stale), where each critic verdict came from, checks you only reported, and brief items nothing checked.
autoharness status shows the harness and log (--full for everything), audit the decisions,
remove/prune take kept items off, eval record|compare measures runs with and without the
harness.
7. Advanced Scaffolding & Code Intelligence (Zero Token Overhead)
- 8-Slot Modular Harness Scaffolding (Google Research Harness² Model):
autoharness slot— inspect the 8 canonical slots (system_prompt, guardrails, memory, skills, tool_guidance, scripts, subagents, middleware).autoharness slot export— dump the live harness slots state as structured JSON.autoharness slot diff --target <file.json>— compute structural semantic diff against another harness state. - Propose–Probe–Compose Contrastive Loop (Without Ground Truth):
autoharness probe -k 2— generate K candidate harness variants, probe them in sandboxed execution, and synthesize evidence-backed improvements via behavioral contrasts (tool error/loop minimization). - AST Symbol Call Graph & Blast Radius Impact Analysis:
autoharness codemap <path> --impact <symbol>— analyze direct callers, callees, transitive blast radius, and impacted test suites without consuming LLM tokens.autoharness codemap <path> --callers <symbol>— locate all direct callers across the repository.autoharness codemap <path> --arch— detect module dependency cycles and architectural boundary violations. - Anti-Shim & Fake Implementation AST Sentinel:
autoharness codemap <path> --check-shims— detect fake agent shortcuts, stubs, and mock cheats (EMPTY_STUB_BODY,TRIVIAL_RETURN_STUB,NOT_IMPLEMENTED_STUB,TRIVIAL_ASSERTION_CHEAT) without LLM tokens. Integrated automatically intoautoharness evidence diffto guard evidence against hollow agent completions. - Consequence-Aware Approval & Blast Radius Simulation (Hugging Face arXiv:2610.40753):
autoharness simulate <target> [--action-type <type>]/autoharness permissions simulate— simulate action blast radius, reversibility tier (IRREVERSIBLE,HIGH_RISK,REVERSIBLE,READ_ONLY), risk score (0-100), and rollback guidance before human-in-the-loop approvals. Exposed to agents viaharness_simulate_actionGateway MCP tool. - Intelligent Cascading Output Compression (dean0x/skim Model):
autoharness skim <file_or_command> [--kind auto|pytest|diff|traceback|compiler|generic] [--max-lines 60] [--json]— collapse passing test progress, verbose context, and noisy compiler logs by 70-95% while isolating failure anchors and root-cause exception lines with head+tail preservation. Persists full uncompressed logs to.autoharness/logs/for drill-down debugging. Exposed to agents viaharness_compress_outputGateway MCP tool. - Self-Supervised Code Refinement & Regression Sentinel with Rollback Guard (Google Research Harness² Model):
autoharness sentinel run [--test-command <cmd>] [--auto-rollback] [--pre-flight] [--no-shims] [--json]— execute pre/post-flight test verification alongside AST Anti-Shim checks; automatically rolls back destructive regressions or fake stubs to verified baseline snapshots.autoharness sentinel snapshot [--label <name>]— capture an atomic working tree fingerprint and lightweight file backup.autoharness sentinel rollback [--snapshot-id <id>]— safely restore repository to a verified snapshot with fail-safe protection against uninitialized state and automatic untracked artifact cleanup.autoharness sentinel status— inspect the active baseline snapshot and last verification result. Exposed to agents viaharness_sentinel_verify,harness_sentinel_snapshot, andharness_sentinel_rollbackGateway MCP tools. - Dynamic Context Compactor & Layered Session Folding (Google Research Harness² & ACP Model):
autoharness compact run [<transcript_path>] [--keep-last 5] [--epoch-size 10] [--json]— multi-tiered context window compression (Tier 0 Recent verbatim, Tier 1 Distill filtered with cascading skim, Tier 2 Epoch condensation) saving 70-85% token volume while keeping full reversible logs in.autoharness/folded/.autoharness compact status [--json]— inspect session compaction statistics, token reduction metrics, and active registry.autoharness compact prune [--keep-last 5] [--json]— rotate and purge older folded transcripts to reclaim disk space with atomic state registry synchronization. Exposed to agents viaharness_compact_sessionandharness_session_statusGateway MCP tools. - Multi-Agent Contract-First Artifact Barriers & Role Isolation for Swarms (Google Research Harness² Model):
autoharness swarm verify [<plan_id>] [--json]— audit DAG topology and validate declarative task artifact barriers (expected_artifacts,barrier_assertions,allowed_paths) and role boundaries (researcher,coder,verifier,critic). Blocks downstream branches immediately when an upstream barrier fails to prevent cascading agent hallucination. Exposed to agents viaharness_swarm_verifyGateway MCP tool. - Dynamic Memory Drift Detection & Knowledge Reconciliation (Google Research Harness² Model):
autoharness memory reconcile [--prune-orphans] [--kind all|ruling|lesson|review|followup] [--json]— audit SQLite persistent memory (.autoharness/memory.db) against ground-truth workspace files and AST symbols. Identifies orphaned records (deleted task directories or missing code files), stale references, and conflicting prescriptive policies with multi-token domain matching. When--prune-orphansis specified, permanently purges broken entries within an atomic databaseSAVEPOINTtransaction while protecting historical review artifacts. Exposed to agents viaharness_memory_reconcileGateway MCP tool.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

