Systems, and what each one proves.
Client work appears here in a form that names no client and no employer. The engineering is real, the numbers are measured, and where a figure came from a person rather than a file it is marked as such.
This is the only page that names the things we have built. It runs from the system with the most at stake to the smallest one worth keeping: a deployed client platform first, then the harness the method is being built into, then an agent architecture, then the foundations and the smaller tools. The governance line closes the page, newest generation first, back to the one still running in production.
An AI platform that reads engineering drawings and prices the job.
A contractor priced every bid by hand. Estimators read hundreds of pages of drawings and specifications, then built a bill of materials line by line. It was slow, it did not scale, and the cost of a missed line item landed after the bid was already submitted.
Extraction was the obvious build. Trust was the hard one. An estimator who finds a single invented quantity abandons the tool permanently, and no accuracy percentage recovers that. So the first deliverable was not code. It was a definition: a quantity left empty and flagged for review is correct, an invented one is a defect.
The client-facing front end of the engagement through to signed work, then the roadmap for what got built: specifications, sequencing, scope, schedule, quality and cost across a distributed team. The clarification cycle ran through eight open requirements and twenty-six follow-ups ranked by risk, and closed into an approved technical and commercial proposal.
- Prototype
- Three weeks from first commit to delivered feasibility study and estimate
- Accuracy
- 38 line items on a live 70-page tender set, zero fabricated quantities
- Priced
- A 60 to 92 developer-week programme, won
- Platform
- 315 commits, 1,081 tracked files
- Scale
- ~93,000 lines across three languages, ten modules
- Test gates
- 546 and 1,278, both at zero failures
An early assessment said the system was reading about three percent of a tender set, and concluded that a complete bill of materials could not be built from it. Checked against the source documents, that was wrong. The pipeline had been pointed at the wrong five pages. A different problem, with a smaller fix.
What it changed: Instead of redesigning around a limit that did not exist, we removed the page ceiling and re-aimed the vision stage.
Why it matters: An error on the cautious side is still an error. Being wrong in the safe direction cost real engineering time.
A ceiling of any value is the same defect at a different number. A 380-page set truncates at 150 exactly as it truncates at 5. Correctness of the bill of materials is the product; a page count is not a design decision.
A decision record, written the day it was made
Structural guarantees, not conventions
An import rule forbids LLM libraries inside the deterministic document engine. The boundary cannot be crossed by accident, because the build fails.
A publishable mirror, gated
Code reaches a public repository only through an export, strict cut, scrub and verify pipeline that runs on explicit instruction. Verified clean: the client and employer names appear zero times in the mirror.
An incident, root-caused
A silent truncation bug in production was traced to a database column limit and fixed with a structural boundary rather than a wider column alone. Written up, not patched over.
keel: letting an agent work without letting it work unsupervised.
The platform above had a client insisting on accuracy. This one has nobody insisting on anything, which is the harder test of whether the method is a method or a reaction to pressure.
An AI coding agent is fast and confident, and both qualities are dangerous when the work is real. It will change what it was not asked to change, report success it cannot substantiate, and lose the reasoning behind a decision the moment the session ends. Telling it to behave does not solve this. Nothing checks.
Make the rules structural. Writes are gated behind an approved plan. Sessions close with accounting verified against an append-only audit log rather than trusted. The policy that binds the model is locked against the model's own hand. Reviewers get no write tools, so a reviewer physically cannot fix what it is reviewing.
Pre-alpha. The repository is public, linked at the head of this section, and the single supported install path is the Claude Code plugin marketplace. It is armed on its own repository and on the projects we work in daily, which is how the gates get tested against real work rather than a demo. A published cut ships with no policy file. It enforces nothing until the person installing it arms it. The machinery ships; the arming is the one decision left to the human.
- Source
- 443 tracked files, measured on the public repository 2026-09-07
- Tests
- 2,898 test functions in 92 files
- Ratio
- 60,651 lines of test against 44,123 of implementation
- Dependencies
- Zero, verified by import analysis
- CI
- Full suite green on Linux, macOS and Windows together, 2026-09-07
- Records
- None in the published cut, by design; the ledgers stay in the maintainer's repository
- Lock
- 28 probes, 18 refused, 10 allowed and each one named, measured once on 2026-08-31
Nothing is written without an approved plan
The gate intercepts every write, edit and shell call. No plan, no write. The exit code is the decision.
Work is routed by complexity
A fast tier for read-only research, a default tier for scoped implementation, a deep tier for tasks flagged complex or for retries after a failed review.
A panel that cannot touch the code
Correctness, security, silent failure, test quality and solution size, each a separate reviewer holding read tools only.
A failed review goes up a tier
With the findings attached, so the retry starts from what was wrong rather than from the beginning.
Sessions close against the log
Accounting is checked against an append-only audit record instead of taking the agent's word for what it did.
The trail is a by-product
Decision and knowledge records fall out of the work, so the audit trail exists without anyone maintaining one.
The day the gate denied everything
A syntax error left the gate module undefined. The fail-closed design did exactly what fail-closed means and refused every tool call on the machine, including in projects that had never adopted it. We wrote the incident up the same day, and the report names the design flaw rather than the typo: a gate that denies when it cannot verify itself has no degraded mode.
This is on the site deliberately. Anyone can show a green dashboard. What tells you how someone builds safety-critical tooling is what they write down on the day it bites them.
The day the log lost a line
Two hook processes appended to the audit log in the same instant on Windows, and the shorter line overwrote the head of the longer one. One event is gone, which is the one thing the log promises not to lose. The ruling was that the corrupt line stays until the writer is fixed and the fix is proven, so the evidence outlives the embarrassment. Four tests are red on the development machine by design until then.
Nine agents, one deterministic orchestrator.
Both systems above are governed from the outside. This one had to put the constraints inside the architecture, because there is no gate to hang them on when the work is spread across nine agents.
A recruitment pipeline where nine specialised agents handle distinct stages of assessment and screening. The interesting decisions are the restrictions, not the capabilities.
- Routing is deterministic. A status machine decides what runs next, not a model. The orchestration is predictable and testable; only the work inside each stage is probabilistic.
- Agents never touch the data layer. An MCP server is the single gateway to the database. The rule is written as an explicit anti-pattern, so it survives contact with a hurried change.
- Concurrency is capped. Model calls are bounded rather than left to fan out, because cost and rate limits are design constraints and not surprises.
- Two-track evaluation. Transcript assessment runs on separate tracks so one signal cannot quietly stand in for the other.
The same data, read a second way.
The tree argues from where the work comes from. This one argues from how much of it there is: every job in a business plotted around what the business knows, coloured by function, with the live ones marked.
Two readings of one dataset is not duplication, it is a test. If a picture only works in one arrangement it was decoration; if the argument survives being redrawn, it was structure. The dataset here is illustrative.
Three large systems say what we can carry. These say what we do when nobody is watching and the thing is small enough to cut a corner on.
04 · What they prove: the small things nobody auditsRange, and taste in small things.
Aion
A reusable admin foundation for building several business applications from one codebase. Every layout feature is a typed configuration flag, navigation is data-driven, and theming runs on extracted design tokens. 54 commits. Derived from an MIT-licensed base, and its README says so plainly rather than implying originality.
diviner
A persistent awareness layer that holds the live state of one project and brokers it between two different AI tools over MCP. Thirteen tools, five prompts, a git ingest hook. Its README lists its own sharp edges, and sets a two-week honesty test where a friction log, not a diagram, becomes the specification for the next version.
context-keeper
Keeps long AI coding sessions accurate after compaction, by re-injecting what was lost from the transcript rather than asking the user to repeat themselves. Designed to cost nothing on a normal turn, which is the only reason a tool like this gets kept.
Earlier career: enterprise web applications in warehouse management, intelligent document capture, fax and routing platforms, and food and beverage loyalty systems. ASP.NET, Angular, SQL Server, WPF, automation testing. Full history
Everything above is a system built for somebody else. What follows is the line of tools built to govern how that work gets done, which is the only reason the systems above can be described the way they are.
The governance lineFour generations, newest first.
Each one keeps what held in the last, repairs what broke, and records why. They are laid out newest first, because the most recent answer is the one worth arguing with. The oldest is also the only one still doing daily work on a live delivery project.
A governed agent harness: the structural spine under an AI coding session. It gates writes behind an approved plan, closes sessions with accounting verified against an append-only audit log rather than trusted, and locks the policy so the model cannot rewrite the rules that bind it.
A run graph for a research crew: a planner decomposes the brief, a router fans it out to scouts, results merge, citations are checked, a writer drafts and a verifier signs off, all of it reading and writing a shared context bus. The graph rewires itself as the run proceeds, because the topology is a consequence of the work rather than a diagram drawn beforehand. This is one frame of a run. The trace is a fixture, not client data.
- Skills
- Nine, covering adoption, session resume, intent interrogation, knowledge capture and retrieval, decision ratification, policy change, wave review and session close
- Agents
- Eight. A fast researcher, a default executor, a deep executor, and five reviewers
- Reviewers
- Correctness, security, silent failure, test quality, solution size. Read tools only
- Lifecycle
- Eight session events wired to one dispatcher: start, prompt, pre-tool, post-tool, stop, subagent stop, compaction, end
- CLI
- Ten subcommands including survey, doctor, attest, leak-check and review
- Dependencies
- None. Standard library only, verified by import analysis
- Test code exceeds production code. 60,651 lines against 44,123, with 2,898 test functions.
- Three operating systems. The newest run was green on Ubuntu, macOS and Windows together on 2026-09-07. The matrix also checks that generated configuration was not hand-edited.
- Documentation cannot drift. A reference-integrity gate fails the build when a document cites a path or rule that does not exist.
- A doctor command. Synthetic hook launches and a known-broken-pattern scan, because a quiet gate is not the same as a working one.
- Records accumulate. Decision and knowledge records are produced by the work rather than alongside it. The published cut deliberately ships none of them.
keel is published now, which is not the same as finished or supported. The repository is public, linked at the head of this section, and the single supported install path is the Claude Code plugin marketplace. Its own README still calls it pre-alpha. Installing arms nothing: the gates enforce only in a project that carries its own policy file at an enforcing tier, and arming is the adopter's own act. The newest green evidence on three operating systems is dated 2026-09-07. What exists is a working kernel, armed on real projects, with the test suite and the incident record to show for it.
charter
54 commits · Jul 2026A governance layer for a body of work: a ratified instrument that states the rules, a lawful amendment procedure for changing them, and a decision ledger recording what was decided and why.
The advance over the previous generation was grading. Fourteen general rules, each independently set to off, advisory, warn or block, with waivers and a baseline that grandfathers existing violations rather than pretending a codebase is already compliant.
The secrets gate is a best-effort tripwire scoped to write and edit calls, and it fails open, loudly, on its own error. It is not a general-purpose secret scanner.
charter README, on the limits of its own protection
That paragraph is the reason this tool is on the site. Anything can claim to protect you. Very little tells you exactly where the protection stops.
Every number above came from somewhere.
The markers on this page open the file or the command behind each figure. The rules those figures are held to, and the reason a page limit counted as a defect rather than a setting, are written down separately.