Overview

We build the machinery that makes AI work verifiable.

Twenty years in software. The last two spent taking AI from an ambiguous client brief through discovery to systems that run in production, and building the governance that lets anyone else check the result. Every number on this site carries the file or the command that proves it. Click any marker.

This is the whole argument in one read, in the order the argument is made. A worked example first, because a claim is worth less than a case. Then how the method reached its current shape, what we are called in to do, what the systems prove, and what enforces any of it. Each part has a page of its own if you want the detail.

A worked example

On a live seventy-page tender set, the system produced thirty-eight line items with zero fabricated quantities.

Status
verified
Measured against
the client's own completed manual takeoff
Definition of correct, set before the build
empty and flagged = correct · invented = defect
Plate I

What AI adoption actually looks like.

Roots are the knowledge a business already holds. Boughs are its functions. Every leaf is one job AI could do, and the count in leaf is how many are actually live. That gap is the conversation.

A drawn tree on a navy ground. Every leaf is one job a business could hand to AI, coloured by the department it belongs to; the roots are labelled with the knowledge that feeds them - proposals and SOWs, call transcripts, contracts, case studies, brand voice, CRM records, pricing and rates, delivery playbooks.
The tree. Roots are knowledge sources, leaves are jobs, in leaf means live.

Built to make one point to a room that has been pitched three AI platforms: you cannot judge any of them until you can see how much of the work is actually running. Thirteen of a hundred and thirty-seven is not a failure, it is a baseline, and a baseline is the only thing that makes the next number mean anything. The dataset here is illustrative.

315
commits, production platform
2,898
tests on the harness
4
governance generations
0
fabricated quantities
01 · What we claim

Governance that cannot be falsified is decoration.

On an AI platform that reads engineering drawings and extracts a bill of materials, the hard part was never the extraction. It was trust. An estimator who finds one invented quantity stops using the tool for good.

So before any code was written, we defined what correct meant, in a form that could be proven false: a quantity left empty and flagged for review is correct, an invented one is a defect. On a live seventy-page tender set the system produced thirty-eight line items with zero fabricated quantities. Checked against the client's own completed takeoff, it correctly named the drawing sheets it had never been given, where the bulk quantities lived. It found its own blind spot, and we led the report with that.

That is the whole method in one story. Define correctness first. Make the definition falsifiable. Report the gap before anyone else finds it.

One worked example shows the method holding once. What follows shows it being rebuilt four times, because a method that has never been revised is one nobody has tested against its own failures.

02 · How it got here

Four generations of the same problem, in six weeks.

How do you let an AI agent do real work without letting it quietly do the wrong work? We have answered that four times. Each generation keeps what held, repairs what broke, and writes down why. The failures are in the record, not buried.

The governance line was not built after the work. It was built during it. The estimating platform, the foundations and the four generations of enforcement were all in progress in the same weeks, and each generation was used to build the next: the plan gate that guards a write was itself written under the plan gate before it. The platform's three weeks from first commit to a delivered feasibility study happened inside that loop. We think the loop is why. That is a judgement, not a measurement, and the record marks it as ours.

Each generation is described here by what it decided. The named brief on each one, with the commit counts and the test gates, is on the case studies page.

First
mid Jul 2026
hand-built

Gates wired into the session itself

still in production

A plan gate and a stop gate wired straight into the session lifecycle. Its founding idea survives in everything after it: every project gets observability, only projects that opt in get enforcement. It also introduced the policy lock, which makes the rules unmodifiable by the model they bind.

Second
19–25 Jul 2026
14 commits

Rules that change only by ratification

ratifiable law

Generalised the rules into versioned personal law: ten timeless articles, eight swappable appendices, and a real amendment procedure with a logged history. Reached version 1.3.0 through four ratified revisions in six days. Compiles to three different surfaces so the same law travels to any tool.

Third
26–31 Jul 2026
54 commits

Enforcement you can grade rule by rule

graded enforcement

Brought back real enforcement hooks and added what the previous generation lacked: a catalogue of fourteen general rules, each independently gradable from advisory to blocking, with waivers and a baseline that grandfathers existing violations instead of pretending they are absent. It is also honest about its own limits in writing, describing its secrets gate as a best-effort tripwire rather than a scanner.

Fourth
Aug 2026, active
443 files public

A harness that fails closed

public repository

A governed agent harness with fail-closed gates, an append-only audit log that is verified rather than trusted, and a review layer of specialist agents that physically cannot write. Test code exceeds implementation code. The full suite runs on three operating systems, green on all three together on 2026-09-07, and it includes a check that fails the build when documentation cites a path or rule that does not exist.

Full technical brief on each generation

The four generations are how we think. This is the shape the thinking arrives in when somebody hires it.

03 · What we are called in for

What we are brought in to do.

AI delivery, brief to production

Discovery with people who are not technical, requirements interrogation, a priced proposal, then the build. Five engagements fronted, all reaching an approved proposal.

Applied AI governance

Responsible-AI deliverables mapped to NIST AI RMF, ISO/IEC 42001 and the EU AI Act, with data residency and redaction before any document reaches a model. Third-party licensing diligence traced to component level.

Agentic systems and harnesses

Task routing by complexity, read-only research agents, separation between the agent that writes and the agent that approves, evaluation and review panels, and audit trails that fall out of the work.

Evaluation and accuracy standards

Defining what correct means before building, then proving it on the whole corpus rather than a sample. Empty and flagged beats invented, every time.

Enterprise systems engineering

Two decades of configuration, workflow building, data migration, integrations and adoption across warehouse management, document capture and loyalty platforms. .NET, Angular, SQL, Python.

Enablement and adoption

Carrying an AI adoption remit for product teams: where AI belongs in the product, the guardrails on agent output, and the onboarding that makes developers productive in an agentic workflow.

Everything above is what got built. This is what stops any of it being quietly abandoned on a bad week, which is the only reason it is the last section rather than the first.

05 · What enforces it

Rules only count when something enforces them.

Seven practices show up in every project, and each one is enforced by a mechanism rather than by remembering.

What is written down
01

Correctness is defined before the build starts

And stated so it can be proven false. A definition nobody can fail is not a definition.

02

The writer is never the approver

Separated structurally. The reviewer agents in the current harness hold no write tools at all.

03

Verification runs on the whole corpus

Not a sample. A migration gate cleared every page before cutover, not a representative few.

04

Paid and irreversible actions are disarmed by default

Arming is deliberate, bounded and logged. Cost has a stated ceiling before it runs.

05

The record is written as the work happens

A successor should be able to continue without anyone's memory. Decision records accumulate as a by-product.

06

Unsourced numbers get deleted, including ours

An estimate we could not trace to a file was removed rather than softened. That is why the markers on this page exist.

07

A guard is proven by breaking it

A new check is sabotaged on the real file and watched to fail, with the failure quoted. Three checks were green and doing nothing until someone did.

What a first ninety days would look like

Evidence from week one, rather than a document at the end.

an offer, not a record

This is what we would propose, written down so it can be argued with before anyone signs anything. It is an offer rather than a record - the sequence below is designed to produce evidence from week one, which is the only part of it worth judging in advance.

Most AI governance programmes stall in the same place: a policy gets written, nobody can evidence it, and the second question from an auditor has no answer. The sequence below exists to produce evidence from week one.

Before anything starts

Three questions decide the shape of the work, and none of them is technical.

Are you a provider or a deployer, per system?

It is per system, not per company, and it sets which duties land on you at all. Most organisations answer this wrong on first pass.

Where do you operate, and where do your users sit?

EU, US state and Gulf regimes diverge on the things that cost money - a named accountable officer, impact assessments, incident reporting.

What has already shipped without review?

Not a blame question. The AI already inside procured software is the largest uninventoried exposure in most organisations.

Days 1-30

Find out what is actually running

No controls yet. You cannot govern a population you have not enumerated, and every programme that skips this ends up writing policy for an imagined estate.

  • A use-case inventory covering built, bought and embedded AI - including the AI arriving inside software nobody classified as AI.
  • Provider or deployer determination per system, written down with the reasoning.
  • A shadow-AI pass. Expense records and browser-extension inventories find more than a survey does.
  • Data provenance for anything that touched training or fine-tuning.

An inventory a regulator would accept as an inventory, plus a one-page exposure summary for whoever signs.

What would be handed over
Days 31-60

Triage, then controls where they matter

Risk-rank the inventory and put controls only where the ranking justifies them. Uniform control across a mixed estate is how programmes become expensive and ignored.

  • Impact assessments on the systems that warrant one, structured to produce evidence rather than prose.
  • Human oversight that is real: a named person, a decision they can actually take, and a record that they took it. Nominal oversight fails the moment it is tested.
  • An acceptable-use position that survives contact with how people already work - the safe path has to be the easy path.
  • Technical controls proportionate to the surface: prompt injection, tool misuse, memory poisoning, and the blast radius of an agent that holds credentials.
  • Incident definition. Most organisations cannot say what an AI incident is, which means they cannot report one.

A risk-ranked register, assessments on the systems that need them, and a control set mapped to the obligations that actually apply.

What would be handed over
Days 61-90

Make it evidenceable

The phase almost everyone skips, and the reason programmes fail their first external review. A control that leaves no trace is an intention.

  • An evidence pack per system: what the control is, who owns it, when it last ran, and where the record lives.
  • Contemporaneous logging, because evidence assembled after the question is asked is worth very little.
  • A vendor questionnaire that gets useful answers rather than marketing ones.
  • Decision records with revisit triggers, so the programme survives the people who started it.
  • A monitoring routine for regulatory change, with coverage reported per source so silence is never ambiguous.

An assurance pack that answers the second question, not just the first - and a standing process that keeps it current.

What would be handed over
Who needs to be in the room

Small group, real authority. Legal or compliance, someone from security, one engineering lead who can say what is actually deployed, and one executive who can stop a launch.

If nobody in the room can stop a launch, the programme is advisory and will be treated as such.

How you would know it failed

Stated up front, because a plan that cannot fail is not a plan. By day 30 there is either an inventory that surprises someone, or the exercise was too shallow. By day 90 you can either produce evidence for a named control without preparation, or the programme only ever produced paperwork.

Both are checkable, and we would rather be measured on those than on whether a policy got written.

Ten questions, typed verbatim

The method is easier to show than to describe.

These are from live working sessions, traced back to the turn. Lightly punctuated, otherwise unedited - including the first person, because they are quotations rather than copy.

  1. 01

    For the open questions, do not assume - always verify before implementation.

  2. 02

    Criticize the behavioral control aspects, and reform it if you were to design the software yourself - use your own terms and definitions.

  3. 03

    First run the benchmark, then add the tool, and rerun the benchmark again to see how much it actually adds.

  4. 04

    Confirm the 33-test baseline still passes before touching anything.

  5. 05

    Do you see a real added value for using both - and what do they really add?

  6. 06

    I'm not sure if the agent was hallucinating. Make sure we don't lose anything or end up with malfunctioned code.

  7. 07

    First evaluate it as code and architecture, so we don't upload something the world sees as odd to what is commonly and professionally used.

  8. 08

    The evaluation should be based only on my chat and code sessions, not my profile - with no bias.

  9. 09

    Check only. Don't change anything.

  10. 10

    Does it use or expose any of my credentials to fetch the data from those platforms?

Three is a controlled before-and-after experiment, specified so the measurement captures what a tool adds rather than what it avoids. Four names a regression baseline that has to hold before anything is touched. Ten asks the credential question before the integration, not after it.

The paragraph nobody writes

We keep a public record of what we got wrong.

Four documented cases where a claim of ours was caught and corrected, including one where a subordinate agent challenged our measurement and turned out to be right. Each one is filed on the page carrying the claim it corrects rather than gathered somewhere separate, because a correction kept away from the thing it fixes is easy to miss and easy to discount.

Next

Available for AI delivery, governance and agentic systems work.

Individuals, teams and organisations. Remote from Egypt, hours overlapping UK, EU and US, open to relocation.