I rebuild real systems, then publish where the design broke.
Kubernetes' API server, reimplemented far enough that the real kubectl can't tell. A browser tab scheduler that holds a memory budget you name. A search engine with its own crawler, index and ranker.
I'm Seth Wheeler, a software engineer and graduate student. Day to day I work on platform and integration engineering (Node microservices, Kubernetes, CI/CD) and, increasingly, MCP servers and retrieval-augmented tooling. What keeps pulling me in is systems that have to hold a resource contract under concurrency: schedulers, protocol implementations, anything whose correct behaviour is only observable from outside the process that's supposed to guarantee it.
Start here
- Evaluating my work
- The write-ups are the best evidence of how I work: a modelling error I found in my own design and quantified, and a bug that was only observable from outside my process. Background on the about page.
- Here to read code
- nodejs-k8s is the most substantial public codebase, and the compatibility claim is testable in about a minute with a
kubectlyou already have. The projects page has the measured detail on each one. - Just browsing
- All writing, or the feed.
Projects
nodejs-k8s
Kubernetes' core APIs, reimplemented in Node. Point your real kubectl at it.
Pods, deployments, replica sets, services and jobs served over the same REST surface the real API server exposes, so the unmodified kubectl CLI and standard YAML work against it unchanged.
Kestrel
A macOS browser that holds whatever tab-memory budget you set it.
~7,900 lines of Swift on WKWebView. Background tabs are demoted down a ladder of measured states to stay under budget: at 800 MB it destroys zero tabs where discard-LRU destroys 5, for 1.5% more memory. Not public yet.
social-deduction-bench
Social deduction as an LLM benchmark: scored per turn and corrected for chance, not ranked by win rate.
522 games across 19 models, measuring deception and deception-detection separately, with a rule-based control that nothing has beaten yet.
reckoner (research)
Fifty-plus experiments on whether language-model capability really needs billions of parameters.
A mixture-of-experts streaming cost model validated byte-for-byte against a runtime I didn't write, and to 1.1% against an unrelated model; then a 276B model run from SSD whose bytes-per-token prediction held while its speed prediction missed by 23×, for a limitation declared in advance. Not a public repo; the write-up is the artifact.
video-timeline
Hands a video to a language model as a measured timeline, not a pile of screenshots.
Turns an MP4 or MOV into timestamped intervals (shot boundaries, camera-motion vectors, on-screen text, audio activity) so the model reasons about what happened between frames instead of inventing it. Python over ffmpeg and Tesseract; no sample video ships, because the test fixtures are generated with known contents.
sql-nodejs
An in-memory SQL engine on npm with a hand-written parser and genuinely zero dependencies.
Parses SQL strings and answers SELECT with real column projection over its own table and row storage. Deliberately small (one equality per WHERE, no joins or aggregates) and the limits are listed in the README rather than discovered.
webCrawler
A search engine (crawler, inverted index, BM25 ranker) with no Elasticsearch.
A hand-written robots.txt parser and a politeness limiter that survives 100 concurrent worker processes, asserted against what the crawled server actually received rather than what the limiter reported.
Postmastr-Backend
A mailroom tracker that reads shipping labels off a photo and emails the recipient.
Tesseract.js OCR over label images, wired into a Node/Express and MongoDB backend.
Writing
- The same model scored -0.400 and +0.078 in one run. The difference was 52 games.
I built a benchmark to rank language models on spotting liars, then ran 522 games of Mafia through it. Day 1 accusations came in at -0.005 against chance on n=2,103, the control that cannot learn disagreed with itself by more than any two models differ, and the whole thing reproduces in 11 seconds with no API keys.
- Error feedback made Adam 1.9x worse than no correction. My fix was measuring something else.
Error feedback makes a biased gradient compressor unbiased over time, and under SGD it restored the full-precision trajectory to three digits. Under Adam it landed 1.9 times further from the optimum than no correction at all, and the fix I published helps just as much with no quantization in the run.
- My completer gets 54.6% of tokens right. Its ghost text is right 7% of the time.
A hybrid n-gram and 2.48M-parameter code completer, tuned dial by dial against its own held-out eval. Then I scored the one feature that emits more than a single token and it came back at 0.070, because the eval hands the model a true prefix and the feature hands it its own output.
- I blamed parameter count. The 8B model logged 279 captures and the engine credited 2.
A preliminary report concluded that models under 3B parameters cannot chain exploits. A later tournament with much larger models put an 8B model last, reading bonus flags off its own machine 232 times while a per-turn marker counted every one of them as a capture.
- I said uniform INT4 only beats NVFP4 after the rotation. It wins 41 of 45 tensors without it.
A palette study on synthetic blocks said evenly-spaced INT4 beats NVIDIA's FP4 grid once a Hadamard rotation gaussianizes the data, and loses by 2.3x without it. On 45 real gradient tensors it wins either way, because my stand-in for unrotated data put the outliers in the wrong place.