ABOUT
Kyle Clouthier
Distributed-systems & infrastructure engineer
I design and build trustworthy systems from first principles, turning research ideas into working software, validating them against real-world problems, and documenting the results.
Today my work focuses on one question: how do you produce a number, a computation, or a decision that anyone can verify for themselves — without trusting whoever produced it? Code that carries its own proof, a result identical on every machine, trust that keeps working when the server is gone.
Focus areas: Distributed trust · Formal verification · Applied cryptography · Reproducible computing
ROOTS
Rooted in the Ottawa Valley
I build from Petawawa, Ontario, a garrison town in the Ottawa Valley, home to one of the largest Canadian Armed Forces bases in the country. I'm not a service member myself, but service runs through my family: my grandfather is a decorated Korean War veteran, and my son has applied to the Forces and looks forward to a lifelong career serving Canada. This is my community, and it shapes what I choose to work on, trust and infrastructure that hold up when conditions are hard and the stakes are real.
It's also why I care about Canada having sovereign, verifiable technology it can depend on: systems whose guarantees you can check for yourself, not take on faith. That's not a slogan, it's why Cairn is built to keep working with no server to phone home to, and why FavourBee exists for the people in communities like mine.
One principle, applied again and again
My work began with a deceptively simple problem: computers don't always agree with themselves. I came up through computational physics, quantum simulations, numerical methods, pushing hardware to its limits, and every computational scientist eventually hits the same wall: floating-point drift. Run enough operations and tiny rounding errors compound until the same code gives different answers on different machines.
So I built exact, error-free arithmetic where every result ships with a receipt anyone can reproduce byte-for-byte. Solving that revealed a bigger idea: the real value isn't precision, it's verifiability, output you don't have to take on trust.
I open-sourced the exact, order-invariant reduction core as bitrep — published for Rust, JavaScript, and Python, with the convergence proved in Lean and a live demo that reproduces the same bytes on your own device. It's the piece anyone can inspect, run, and verify for themselves: the principle, made public. I run that same principle over my own development with Attestral — internal tooling that machine-checks AI-generated code and signs a certificate anyone can re-run.
I followed that same principle into trust (Cairn, a serverless, post-quantum control plane where devices admit and revoke each other offline, every decision signed and replayable) and into memory (Neruva, a deterministic substrate where recall is reproducible and auditable). Different domains, one through-line: determinism you can verify.
Featured systems
Cairn: Serverless Post-Quantum Trust · flagship · under NDA
One architecture, three validated applications: the disconnected tactical/defence edge, identity continuity (enterprise break-glass and government/defence continuity of operations), and OT/ICS device trust (real industrial captures + a live emulated plant). Live transatlantic mesh, adversarially red-teamed (180+ tests, CI on every push), the partition-revocation bound machine-checked in Lean 4, signed replayable audit. Research prototype, TRL ~4–5. Mechanism under NDA.
Attestral: Machine-Checked Code · internal tooling
Internal tooling I built and run across my own projects — not a commercial product. AI-generated functions are machine-checked locally (compile, lint, property tests, and formal proof via Kani, CBMC, Lean 4, Dafny, F* and TLA+), auto-revised from the checker's counterexample, then signed with a certificate anyone can re-run offline. 10 languages, 6 with formal rungs; nothing leaves the machine.
bitrep: Reproducible Float Reductions · open source
The closed work (Cairn) is proprietary by necessity — this is the same discipline in the open, where you can check every claim yourself: a Rust crate for order-invariant, bit-identical float reductions, proved in Lean, checked by Kani, one SHA-256 across four architectures in CI on every commit — plus a live demo that runs the proof on your own device.
Internal research
Neruva: Deterministic Memory
Reproducible recall, provenance, and snapshot/replay audit, the deterministic memory layer I built and run across my own projects. Internal R&D, not a product.
What I build toward
Results should be independently verifiable, output you can check, not take on trust.
Systems should keep working when the infrastructure they depend on fails.
Trust should be earned through evidence, not asserted through claims.
How I got here
For over a decade I was an operator, I built and ran a digital-marketing company (12 years, $2.5M+ in sales, teams up to 12) and ran construction and property businesses from the ground up. When AI began reshaping that market I wound the agency down and went all-in on the work here: deep distributed-systems and security engineering, and the modern AI tooling I now build with. I bring that builder's bias to engineering: ship, measure, prove. The depth: cryptography, numerical methods, formal verification, I learned each discipline because solving the problem in front of me required it, self-directed and evidence-first. Plenty of brilliant engineers never ship, and plenty of operators never build deep technology; I've done both.
I use modern AI tooling to accelerate engineering and research, but nothing ships on the model's say-so, I treat every result as a hypothesis to validate, favoring reproducible evidence, adversarial testing, and formal analysis over assumptions. I even run a second, independent model as an adversarial auditor of the first: on Cairn it surfaced real, critical bugs an earlier pass had missed, which I fixed and locked down with regression tests. Acceleration only matters if you know what to build and how to prove it works.
bulbnoram.com
A recent client product delivered end-to-end, designed, built, and deployed, with a custom AI assistant integrated into the stack.
The why: FavourBee
I built and shipped FavourBee, a free mutual-aid network, a live, full-stack platform built on the same Sybil-resistance principles as Cairn, out of my own lived experience of needing help and a community to lean on. It's the reason this work matters to me: proof that verifiable trust can serve real people, not just institutions.
Let's build something that matters
I'm interested in senior engineering roles, research collaborations, design partnerships, and Cairn evaluations under NDA. Based in Petawawa, Ontario.