the harness
We ship a harness,
not a deck.
Most consulting ends with a document, and a document cannot enforce itself. We end with a running AI agent harness — and what you get is an operation that enforces its own rules, frees your team from mechanical rework, and records every decision so nobody re-argues last quarter's conclusions.
what it is
A working system that runs alongside your team — not a report about one.
It sits inside the work your people already do — the documents, the decisions, the daily process. It does not make the judgment calls, and it is not the AI itself. What it does is hold the rules your operation runs on, turn the way your team works into repeatable procedure, and keep a record of every task, decision, check, and result. After fourteen weeks, the rules, the history, and the way of working are yours to keep.
architecture
- specyour rules
- skillyour methods
- agentwho acts
- runtimethe record
- evidencethe proof
what it enforces
“Done” means the evidence exists — not that someone thinks it’s good.
Finish is evidence-gated
The system will not mark work done until every required check has passed, the artifacts exist, and the verification is on record. A claim of “done” with nothing behind it is simply not accepted.
Mandatory criteria are verified, not self-reported
The checks most tempting to wave through — correctness claims, security surfaces, module boundary compliance — are verified against actual artifacts, not taken on faith from the agent. An agent cannot mark a mandatory criterion passed; the evidence must exist in the record, and the harness reads the record.
Sensitive work is reviewed before it starts
When a task touches a sensitive surface, a security review must be on record before the work is even handed off. The review is a precondition, not an afterthought.
Drift is caught, not discovered
The documentation you encode is checked against what the code actually does. When a module no longer behaves as documented, it flags the gap — not in the post-mortem, but while the work is still alive and fixable.
how the work divides
The agent that builds is never the agent that judges.
Work moves between defined roles through a written hand-off, not a chat thread. Each role has one job — and the one who checks the work starts fresh: it re-runs the checks itself and points to the exact evidence, instead of taking the builder’s word for it.
- one
Architect
Writes the binding design — the contract the build must satisfy — before a line of code is written.
- two
Builder
Implements against that contract, recording evidence as it goes.
- three
Evaluator
Checks the work independently, in a fresh context — runs the tests, cites the evidence. Not a rubber stamp.
- four
Reconciler
Keeps the written rules and the running code in agreement as both keep changing.
in practice
A rule, enforced — not a paragraph in a doc.
Take one rule: no piece of work moves forward until someone has reviewed it. The system makes that sign-off a precondition — it will not let the work advance while the review is missing, and it records the review, the work, the checks, and the result as it goes. The rule does not live in a handbook nobody opens. It is enforced as the work happens, and every step is on the record.
the record
Every decision is written down where it can be read back.
Each task, decision, check, and result is kept in a durable, searchable record — one you can export, and one that survives even if the work is interrupted. The trail is not a by-product; it is part of what you are buying. When a decision is questioned next quarter, the answer — and the rule it followed — is already on file.
not locked in
One method. Your choice of engine.
The same method runs across the major AI agent platforms, so your operation is never married to a single vendor’s AI. The rules, the roles, and the record are yours; the underlying AI is a part you can swap.
- Claude Code
- Codex CLI
- Gemini CLI
core by design
Specability Core is the free local coding-agent harness for the coding domain.
We do not sell a system we would not run ourselves. Core ships signed builds, checksums, public changelogs, and the Starter Pack without automatic code or runtime upload. The full method library advances through Partner collaboration and Enterprise engagements, so the best customer-tested workflows compound into stronger packs.
get Specability Core →how it maps
- one
Discovery
Find the invariants. Read the history; name the few rules that were always doing the work, and the one surface that is genuinely judgment.
- two
Specification
Encode them, once, where everyone can see them. The spec is not documentation of the system; it is the system's source of truth.
- three
Harness
Ship the thing that runs the spec. The boundary between rule and judgment is now enforced by software, not described in a slide.