Neural Lace

# Neural Lace

> An intelligent, self-improving harness that gives AI coding tools the discipline of an entire engineering team — enforced mechanically, not by hoping the AI follows instructions.

**Last verified:** 2026-05-06.

## CI — the harness eats its own cooking

Every push and pull request runs three independent workflows so the harness's own discipline mechanisms are exercised server-side, not just trusted to be correct:

- **Evals** (`.github/workflows/evals.yml`) — runs the 5 golden behavioral tests under `evals/golden/` plus the `validate-pr-template.sh --self-test` battery.
- **Hooks self-test** (`.github/workflows/hooks-selftest.yml`) — discovers every hook under `adapters/claude-code/hooks/` that ships a `--self-test` block (44 as of this writing), runs each one, and also runs the standalone test scripts under `adapters/claude-code/tests/`.
- **PR template** (`.github/workflows/pr-template-check.yml`) — validates the capture-codify section in every PR body.

Status badges for these three workflows are intentionally NOT pasted into this README — the harness-hygiene gate forbids hard-coding the GitHub owner/org into shipped kit files. To embed badges in your fork, add them to a non-shipped doc with your own `<owner>/<repo>` substituted into the URL `https://github.com/<owner>/<repo>/actions/workflows/<workflow-file>/badge.svg`. Red on any of these badges is a stop-the-line signal — the harness's claim "the AI cannot bypass the gate" silently degrades when these tests rot.

## The problem

AI coding tools are powerful but unreliable at production-grade work. They skip verification, hallucinate completion, drift from the plan, forget constraints mid-session, and ship code that compiles but doesn't actually work end-to-end. The more autonomy you give them, the worse these problems get. Telling an AI "always verify your work" in a prompt is like telling a junior engineer "always write tests" — it works until it doesn't.

The deeper problem is that AI agents are amnesiac. Each session starts from zero. The architectural decisions from last week, the discoveries from yesterday's debugging session, the plan state across a multi-day feature build — all of it lives in chat transcripts that vanish when the session ends. There's no institutional memory, no structured handoff, no way to accumulate organizational knowledge.

Neural Lace exists because we got tired of catching these failures manually.

## What Neural Lace is

Neural Lace is a discipline and memory layer that sits between you and your AI coding tool. It implements industry best practices automatically by giving the AI a structured team to operate within — an orchestrator, developers, verifiers, reviewers, and an end-user advocate — and enforces engineering standards through hooks that the AI cannot bypass. The AI doesn't need to remember to verify its work; the harness blocks the session from ending if it hasn't.

Concretely, it's a set of rules, hooks, agent definitions, scripts, and templates that install into your AI tool's config directory, plus global git hooks that scan every commit and push. Once installed, every session inherits the discipline — no per-session opt-in, no self-applied rules.

The key insight: **AI discipline should be mechanically enforced, not self-applied.** Pre-commit gates, session lifecycle hooks, evidence requirements, and scope constraints fire automatically at enforcement points. The harness doesn't ask the AI to be disciplined — it makes undisciplined behavior structurally impossible.

### What makes it different

**Self-improving.** The harness audits itself weekly, captures mid-session discoveries as permanent artifacts, and has a dedicated agent that proposes improvements every time something slips through. It gets better from its own failures.

**Persistent memory across sessions.** Vanilla AI coding tools are amnesiac — each session starts from zero. Neural Lace adds structured handoffs between sessions, permanent discovery capture, decision records (ADRs), a findings ledger, cross-session plan state with evidence, and calibration data that tracks how the AI itself behaves over time. The AI goes from amnesiac to having genuine institutional memory.

**Defense in depth for AI-generated code.** Credential scanning at commit AND push, security anti-patterns flagged before they ship, OWASP-class issues caught by a dedicated security reviewer agent. AI-generated code is particularly vulnerable to these patterns and Neural Lace is built specifically to catch them.

**Narrative integrity.** The AI cannot claim it's done when it isn't. Sessions literally cannot end if the transcript shows deferred work, self-contradiction, skipped user directives, or unfulfilled goals.

**Progressive autonomy.** Trust accumulates through safe operation. The AI earns more freedom by demonstrating reliability — fewer interruptions, more autonomous multi-task execution. Hard blocks (credential exposure, public access changes) never 

... (truncated)