Case studies

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.

deployed and live .NET · Python · Angular LLM vision 2026
01 · What it proves: trust under accuracy pressure

An AI platform that reads engineering drawings and prices the job.

The problem

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.

The real difficulty

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.

What we owned

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.

Measured outcomes
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
Where this case was measured wrong

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.

public repository Python, standard library only 2026 github.com/policyon/keel
02 · What it proves: enforcement, not documentation

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.

The problem

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.

The approach

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.

Honest status

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.

Measured
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
The keel orchestration dashboard, live. Captain, the orchestrator that plans, routes and reviews, sits at the centre of a session graph; executors Chief and Shipwright, researcher Lookout and reviewers Surveyor and Gunner surround it, each tagged with its model tier and its finished-and-reviewed state. A plan ledger at the right shows 11 of 12 tasks done, above an event feed of reviews, hand-offs and gate blocks.
The read-only local viewer showing delegations as they run. The session shown is a demo fixture, because a real one names the work it is running against and that is withheld here. The gates themselves are armed on real projects, as above.
How a task actually moves
01 · PLAN

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.

02 · ROUTE

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.

03 · 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.

04 · ESCALATE

A failed review goes up a tier

With the findings attached, so the retry starts from what was wrong rather than from the beginning.

05 · ACCOUNT

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.

06 · RECORD

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 failure worth showing

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 record kept its own damage

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.

multi-agent .NET 8 · Semantic Kernel · Angular MCP
03 · What it proves: agent architecture with real constraints

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.
Plate II

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.

A radial map. A centre marked Second brain, seven department nodes around it - sales, deals, marketing, operations, intelligence, customer, back office - each carrying its job count, and a ring of small circles beyond them, one for every job.
Capability map. The same jobs again, arranged by function around what the business already knows.

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 audits

Range, and taste in small things.

Angular 21 · Tailwind v4

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.

Python · MCP · SQLite

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.

developer experience

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 line

Four 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.

Fourth generation

keel

plugin marketplace install github.com/policyon/keel

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.

The keel orchestration dashboard, live. Captain, the orchestrator that plans, routes and reviews, sits at the centre of a session graph; executors Chief and Shipwright, researcher Lookout and reviewers Surveyor and Gunner surround it, each tagged with its model tier and its finished-and-reviewed state. A plan ledger at the right shows 11 of 12 tasks done, above an event feed of reviews, hand-offs and gate blocks.
The orchestration dashboard. A live session graph beside the plan ledger and the audit event feed.

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.

What is actually in it
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
Why it holds up
  • 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.
Stated plainly

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.

Third generation

charter

54 commits · Jul 2026

A 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.

Next

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.

Start a conversation Read what is written down →