Incident intelligenceBuilt
Incidents investigated against the estate’s own history.
For a global aerospace, defence and space group, I built a unified cloud operations portal: 650+ commits and roughly 240,000 lines in eight months. Its AI layer investigates incidents with a frontier model served through Amazon Bedrock, grounds each investigation in hybrid keyword-and-vector search over past incidents, groups similar incidents semantically, and gives the assistant tool access to the ITSM, observability, network, identity and cloud systems, while user actions are kept in an append-only audit trail.
Sovereign inferenceBuilt
An 80B-class model at 256K context on two consumer GPUs.
I run a private AI fabric of two consumer GPUs, 24 GB and 32 GB, joined by a direct 2.5 GbE link. A 3-bit quantised 80B-class coding model is split layer by layer across both cards at its full 256K context; it passed a needle test at close to 250K tokens and decoded at a median above 90 tokens per second across 230 real requests. The same pool sends image, video and 3D render jobs to whichever host is idle, and no inference is paid for.
Knowledge captureBuilt · then led
Expert know-how captured without letting the model invent it.
I built an AI interviewer, and later led the team extending it, that turns a shop-floor expert’s spoken know-how into a structured training standard. Its extraction step is instructed to keep only what the expert stated, explicitly affirmed or explicitly asked the interviewer to suggest, and a 17-rule deterministic validator, not the model, decides whether the result is good enough. Optional retrieval over public occupational-safety and skills sources may steer the questions, but it reaches extraction only in a reference mode that forbids taking values from it, and the natural-language search the team added shows the model field names only, never customer data.
Neuro-symbolic designBuilt
Layouts the model proposes and geometry decides.
I built a spatial layout engine in which a local model proposes the plan and a backtracking solver, with exact collision, clearance and reachability checks, places every object; a vision model may choose between layouts that already passed but can never overrule the verifier. On its own benchmark of 75 generated scenes, from sparse to dense, the solver placed every scene without collision or refusal. A sibling pipeline turns a 2D plan into a path-traced 3D scene; a diffusion pass then refines materials and light only in the late steps of denoising, so the geometry stays where the solver put it.
Calibrated decisionsBuilt
Probabilities, not prose, from local models.
I built a decision engine that asks a local model a lettered multiple-choice question and reads the probability of a single answer token. It calibrates that probability per model by temperature scaling, averages a reversed-order pass to cancel position bias, and scores itself on accuracy, Brier score and calibration error. On a labelled set of about 100 developer decisions it scores above 85% with a 7B model, at around 20 ms per question, and 99% with a 27B model. Because it is wire-compatible with a commercial decision API, that vendor’s SDK runs unchanged against local models.
Retrieval evaluationBuilt
Retrieval tuned against a gold set, not a demo.
I built a code-search server for agents that fuses BM25 and dense retrieval by reciprocal rank fusion and can rerank with a cross-encoder. It is measured against a 110-query gold set, nearly half mined from commit history, with labels anchored to files rather than chunks so it survives re-chunking and embedder swaps. The measurements showed the dense lane alone was far weaker than BM25, and the reranker lifted NDCG@10 by more than half, from 0.46 to 0.71. An earlier multi-agent orchestration layer was cut so the server could focus on retrieval.
Decision methodologyDesigned
One grammar for people, continuous representations for engines.
I designed a decision methodology that describes every product, space, customer profile and bundle on the same six typed axes. People work with closed, human-readable vocabularies; engines work with continuous representations of the same axes (multimodal embeddings, perceptual colour vectors in CIE L*C*h° with covariance, material feature tensors and a hierarchical spatial scene graph), so fit and coherence are optimised rather than looked up. On top sit a mixed-integer assortment optimiser under grammar constraints, a 3D layout solver, active Bayesian preference elicitation, sequential testing and an information-theoretic positioning engine. Its reference outcomes: a fit score of 92/100, a coherence score of 88/100, every required slot filled, and an 18% higher margin than a manual pick.
Agent tool surfacesBuilt
A tool gateway that lets agents borrow a peer GPU, safely.
I built a Model Context Protocol gateway for each GPU host that gives coding agents eight typed tools and, deliberately, no shell. A node can borrow its peer’s capacity only through size-bounded, hash-verified snapshots run in a network-less sandbox. The model starts automatically only after a VRAM admission check that fails closed. With the serving engine’s prefix caching, time-to-first-token on a 5K-token context fell from 1.2 s to under 40 ms.
Grounded generationBuilt
Images built from the quote, not from a prompt.
For a vertical AI platform, I built image generation that conditions every scene on the product photos in the priced proposal, with a negative prompt derived per scene from the catalogue; in a small internal test (six renders of one scene), duplicate copies of quoted products disappeared, though it does not make the model count reliably. The production model was chosen by a vision model scoring per-product fidelity on a four-proposal comparison (5.2 against 2.0 and 0.1 out of 10), and product swaps are stitched back so that every pixel outside the edited region stays byte-identical.
Neuro-symbolic guardrailsBuilt
The model chooses; the catalogue owns every price.
For the same platform, I built proposal generation in which a single JSON-mode model call sits inside seven deterministic stages. Those stages discard any product not in the candidate set, overwrite every price and name from the catalogue, and repair budgets and overlap between tiers. The conversational brief that feeds it keeps a fact only if the customer’s own words support it. For made-to-order manufacturing, a pure rule engine decides fit, tolerances, pricing and approvals, and the model may only choose among options that already passed.
GenAI operationsBuilt
Generative AI on self-hosted GPUs, run like a billable service.
I built the layer that lets open-weight language and diffusion models share self-hosted GPUs as a billable service. A coordinator drains the language model before diffusion claims the card; a durable queue with typed failure codes is built so that competing workers never run the same render and a render is billed at most once, only after delivery; and an ambiguous submission quarantines its GPU until the queue proves it absent. If the embedding model answering is not the one that built the index, search falls back to keywords rather than returning wrong neighbours. The cost attribution I led charges each call to the business action that triggered it.
Agent verificationBuilt
The model that produces the work never grades it.
I built a ticket-to-merge pipeline in which one vendor’s coding agent works on an isolated branch, a different vendor’s agent audits the diff against a schema, and only deterministic lint and test gates can merge. So far only its individual stages have been exercised, in dry-run mode: triage correctly declined a non-code ticket and the merge gate ran the affected test suite; no ticket has yet gone through coding and cross-vendor audit, and it is not trusted with production merges. The same principle runs a research tool in which two agent engines each try to refute what the other found. Organisations that cannot be shown to exist are dropped, real ones with stale details are corrected, and stale details proved far more common than fabrication.
Output assuranceBuilt
Generated speech, text and video, checked before anyone sees them.
I build objective gates for generated output instead of relying on spot checks. A tiered translation-quality estimator that can run air-gapped uses a local LLM judge, and that judge caught a terminology mistranslation every structural check had passed. A round trip transcribes synthesised narration back and ranks each line by word error rate; it exposed French voices dropping final consonants. For films, every frame is decoded and scanned, with hashed provenance, before delivery. The quality estimator is built and validated but not yet enabled in production.
Industrial engineering AIBuilt
From CAD drawings to data a workshop can use.
I built an on-premise pipeline, entered in a regional industrial AI challenge, that reads a CAD assembly and its drawings and produces standards-based calculations, Pareto design variants, corrected geometry and operator skills. Engineering rules and closed-form formulas produce the numbers, the models only read, classify and phrase, and every output cites its drawing page or standard.
Local-model analyticsBuilt
Small local models over large operational data.
I built an observability layer for a multi-tenant Kubernetes platform. It redacts tokens and personal data before anything is embedded, runs eleven statistical and vector analyzers, and lets a local model narrate root causes, while operator feedback mutes noisy signatures. For delivery data, I made a map-reduce over a backlog of 3,000+ tickets converge: capping items in code, rather than trusting the model’s grammar, raised compression to about 4× per round. Every ticket key the model returns is checked against the source.
AI-native engineeringPractice
Coding agents, governed like an engineering organisation.
I run coding agents as a governed process: a written spec and a test-first plan come before any code, agents work in parallel in isolated worktrees, and independent reviewers and a second model audit the result. So far that adds up to 120+ specs and 100+ plans across 25+ repositories. On a 200k+ line AI platform, architecture rules live in executable boundary and drift tests. Across a multi-repository production estate, agents may run read-only cluster and cloud commands freely, but every change to clusters, releases, cloud resources or remotes needs explicit approval, guided by a durable memory of verified root causes.
