SENIOR AI ENGINEER @ FYLD · UK
I build production agent systems — and the unglamorous infrastructure that tells you whether they actually work: tracing, evals, reliability. Outside work I run small, careful experiments on how models learn and how we evaluate them.
$ whoami
senior_ai_engineer
$ focus
production_agents
llm_observability
evals
judge_reliability
architecture_research
interpretability
$ now
self-organising-transformer: attempt 9
meta-eval: building the judge panel
$ policy
honest numbers only_
Agent platforms that hold up with real users: tracing on every LLM call, prompt versioning, PII masked before anything leaves the service, retries and model fallback. And deleting LLM calls that don't need to exist — if the model has no real decision to make, it's an if-statement.
LLM-as-judge evaluators, golden sets and functional tests — then the awkward follow-up question: how far can you trust the thing doing the grading? I write the grader before the model.
Small, controlled experiments on architecture and interpretability: dense baselines, multiple seeds, ablations. I publish the negative results too, because that's usually where the interesting part is.
Running AI coding agents like a team: specs, plans, isolated worktrees, review gates and written rules for every failure. The skill isn't typing — it's framing, delegating and verifying.
Can a Transformer learn its own structure while it learns its weights — which layers, heads, FFN groups and skip edges to keep — and end up cheaper than a dense model of the same quality?
Honest status: not yet. The gated models still trail a dense baseline, and I retracted an early "beats dense" result after tracing it to a library bug that broke checkpoint loading. The useful finding: a gate's size doesn't tell you how important a unit is (layer gates correlate at ρ = −0.72 with real importance; a Taylor estimate gets 0.93). Next up: a Phase 2 run (discrete birth and death of units) with a fix that stops dormant units quietly propping up the numbers.
A harness that measures how fine-tuning and quantisation change model safety, and evaluates the evaluators: are common LLM-as-a-judge models biased on safety-critical tasks? A self-audit already caught judges sharing weights with the models they scored. No results yet — the full judge run is next.
Tools for poking at what transformers attend to and why: saliency maps, integrated gradients, logit lens and attention rollout across classification, generative and seq2seq models.
Extending the authors' ICLR 2026 image-immunisation method to SD3.5 and FLUX. Verification tests caught silent training bugs — severed gradient paths and an inverted loss term — that produced plausible loss curves and zero signal. Verified on CPU; GPU validation pending.
Older experiments: ELECTRA pretraining in PyTorch, GNN experiments and neurosymbolic language modelling. Some are polished; others are just me answering a technical question by writing code.
Senior AI Engineer
Technical owner for 7 customer-facing production agents behind a construction-safety product. I wrote the AI platform strategy in my first three weeks — trust first (observability, evals, PII), then extensibility — and have spent the months since building it. Took the platform from zero observability to full tracing, prompt versioning and LLM-as-judge evals, with PII masked before export and separate EU/US data residency. Cutting LLM calls on one agent's first message from 9–12 to 3–4 took its average response time from over a minute to about 20 seconds. Retries and multi-model fallback took daily agent errors from hundreds to single digits. I also mentor, interview and review a lot of PRs.
Python Developer → Engineering Manager, AI
Built the company's AI capability from nothing: NLP and translation models, 30+ computer-vision models, and a customer-facing deep-research agent over 400M+ records, with a 28-query, 6-dimension evaluation suite to prove it worked. Scaled document throughput from ~10/s to tens of thousands per second. Then led a small AI team, before choosing to go back to hands-on technical ownership.
Software Programmer
Robotics PLC logic and computer-vision inspection tools for high-precision manufacturing. Rewrote the flagship inspection programme in six months: +166% machine efficiency.
Software engineer turned AI engineer, with a habit of going one layer deeper than strictly necessary.
I studied Software Engineering at the University of Portsmouth and started out on automation and computer vision. From there I moved through ML engineering into LLMs, agents and production AI — and spent a stint managing an AI team before deciding I wanted my hands back on the hard problems.
What I care about: evidence over assertion, simple systems, honest numbers, and using code when the model has no real decision to make. Increasingly, that means evaluation — most people can build an agent, fewer can tell you how much to trust the thing that grades it.
GET IN TOUCH