🤓 Latest Submissions
TwoHands
Two Hands catches typing errors in digitized handwritten forms: Gemma-4-31B-IT on the AMD Token Factory reads every number twice, as digits and as words, and the form's own arithmetic decides what is accepted. On 1,270 real Mexican tally sheets it found 49 typing errors in the official records, each confirmed by the certified count. How it works: names and signatures are blacked out; Gemma reads each number; plain arithmetic checks it (words must match digits, rows must add up to the total). If everything holds, the form is accepted. If not, only that number goes to a person, with its photo. Every finding gets a verifiable receipt. Results (Mexico, 2024): - 91.6% field match on Baja California Sur's sheets vs 62.84% for the Google Document AI reading the state bought (same metric; ours on a random 300, theirs on all 2,020). - Caught 27 of 28 errors the certified count reveals (pre-registered); 0 wrong in 484 accepted fields on 100 fresh forms. - In a 300-sheet sample audit, the auditor reviews only 267 disputed numbers of 6,358 (4%). Business: first buyers: INE, Mexico's 32 state electoral institutes and their auditors, before June 2027's concurrent elections. $1 per sheet proposed, about 0.5% of what one state paid to run its count; first step a paid pilot. The check is the form's own arithmetic, so it isn't tied to elections: it already works on UK rainfall ledgers from 1850-1960 (same model, no retraining). Next buyers: election bodies in 7 more countries that publish their tally sheets, health ministries' data-quality teams checking DHIS2 clinic reports in 70+ countries, and archives digitizing handwritten records. Why Gemma: same 300 sheets and checks, 1.8x the forms Qwen accepts, 4.6x cheaper, 2.8x faster; a whole state (982 sheets) for $0.14. Evolus: each strong finding opens a case; an agent on Gemma writes it up, a script scores the evidence, the auditor decides. All numbers re-derive from public data (make eval). Built solo.
18 Oct 2026
.png&w=828&q=75)
Solo MC3: Grounded RAG on ROCm -v2
A solo entry for AMD AI League Match 3. The container is pointed at a folder of mixed internal documents, indexes it once, and then answers each question with the value only and the exact set of files the answer came from. When the corpus does not contain the answer, it returns nothing rather than a guess. It reads every file type in the challenge: PDF datasheets including superseded revisions, Word documents with tables, multi-sheet spreadsheets, CSV ticket databases, production logs, source code, and images whose answers exist only as printed text. The corpus traps are handled as the brief requires: an empty directory, an unknown binary type, a file with no read permission and an encrypted PDF are each skipped without stopping the rest of the index. The whole stack runs inside the mandated ROCm PyTorch base image on the AMD GPU, with the model weights shipped in the image and no network access needed at evaluation time. Startup, per-question and whole-run budgets are met with margin, and the output contract is followed exactly.
1 Dec 2026
Earshot: screen-reader tests for AI-written UI
An NVDA user presses Enter on "Select Seat Class" and hears nothing. The Sign In dialog opened silently, and their next Tab lands on the page behind it. Earshot turns that silence into a failing test: the verdict comes from what a real screen reader says, not from the AI agent judging its own code. On three apps I didn't write, lint and axe flagged 3½ of 15; IBM Bob fixed all 15, each verified by a real screen reader. The problem. AI coding agents write more and more UI. Tests check what sighted users see; linters check markup. No test in the AI agent's loop checks what a blind user hears. In WebAIM's 2026 scan of the top million pages, 95.9% had detectable WCAG failures. The European Accessibility Act has applied to e-commerce and passenger-transport booking since 28 June 2025, so for shops and airlines a silent dialog is a legal risk. The apps: IBM's Galaxium Travels, TodoMVC, and Uptime Kuma, a production monitoring tool with ~60,000 GitHub stars. Nothing was planted: the bugs are theirs (the audit is mine). The measurement. axe-core 4.13 flagged 3½, strict React lint none; 11 were caught only by ear. Bob's first F-01 fix added only the dialog's name: axe passed it, NVDA stayed silent, and Earshot rejected it. The solution. - Fix: /hear F-01 puts IBM Bob in a custom mode that can edit only the frontend. Bob states the expected announcement, fixes the code, then calls my MCP tool listen(), which presses real keys in Chrome while NVDA runs and returns its speech. A fix without the expected phrase is rejected; that happened six times. - Discover: /earshot tabs through a page by ear, parallel subagents locate the code, the human triages, Bob fixes and tests. On Uptime Kuma it found a silent Tab stop and a duplicate one inside every monitor link. - Gate: each verified finding becomes a test. A git hook and a Bob hook replay the tests a change can affect, with NVDA, including typing. Told to remove the dialog's focus code as a "tidy-up", Bob complied; NVDA heard silence and the git hook refused the commit; later the Bob hook blocked a --no-verify commit. Typing caught a regression in Bob's own verified F-01 fix, and Bob wrote the test. Why it is new. axe-core and axe's MCP server check rules. Guidepup and a11ign drive real screen readers for human-written tests or audits. Earshot puts the screen reader inside the AI agent's loop, so the agent's test oracle is what a blind user hears: an AI that rejects its own fix because it listened. Adoption. One git command enables the gate; each test is one JSON line; adding a new app took Bob one task; a verified fix cost a median of about 1 Bobcoin ($0.50); checking just 6 announcements by hand took me a minute per commit; the gate replays them unattended. Earshot proves specific announcements on specific key paths; it does not certify compliance.
27 Sep 2026
Ten Places: Bimanual VLA Table Setting
Two simulated SO-101 arms face each other across a randomised dinner table. Say "set the table, but skip the cup" and they do it: open the cutlery drawer, hand the spoon across, place the plate, set the cup, and say when it is done. Speech in and out is Speechmatics. The transcript lands about 1.2 s after you stop talking, and the microphone stays open all run: say "stop" and the arms halt at once, or change your mind mid-run and the new plan takes over when the current step ends, with nothing dropped in mid-air. Qwen3-VL-4B (INT4, OpenVINO GenAI) reads the sentence and the top camera and returns a plan over five skills. A verifier adds what physics requires - the spoon is inside a closed drawer, so the drawer opens first - and every correction is shown. One learned ACT policy per skill then drives both arms at 25 Hz from cameras and joint angles alone: no object positions from the simulator, nothing glued to a gripper, grasps held by friction. A ResNet18 camera classifier checks every step and retries what failed. Neither arm reaches the far half of the table, so the cutlery has to change hands. Results on tables never used for training or tuning: 183 of 200 set completely, four sets of 50. Placement medians 3-4 mm, every placed object inside a 2.5 cm tolerance. Push friction, mass, lighting and colour to twice the training range and it still sets 40 of 50. Object sizes at plus or minus 20% are the real limit, at 27 of 50 - measured and reported, not hidden. Every model on the machine runs in OpenVINO on an Intel Core i5: 39-45 ms in PyTorch, 18-20 ms at FP32, 15.5-16 ms with INT8 weights and an IR four times smaller, with no loss in success. Full INT8 is faster again and halves success, so it is not shipped - precision chosen by what the robot achieves, not by output error. The arms run on the performance cores and the planner on the efficiency ones, which takes late control steps from 97% to 6%. Every number comes from a script in the repo.
16 Sep 2026
Kestrel
Kestrel handles all eight task categories — factual questions, math, sentiment, summarization, entity extraction, code debugging, logic puzzles, and code generation — in a single pipeline. Work starts with a deterministic classifier. It reads the task and works out what kind it is by pattern matching, with no model call: it costs nothing, and it cannot hallucinate a category. That decision drives everything downstream — which model answers, and whether the task leaves the container at all. A quantized 4B model ships inside the image and runs on CPU. I benchmarked it category by category and gave it only the work it genuinely handles well; those tasks never touch the API and cost nothing. The rest are routed per category to the model best suited to them. The part I spent most of my time on is checking answers with code rather than trusting the model. When the agent writes a function, it runs it against the examples in the prompt, and a failure goes back with the failing case attached — an interpreter is a far better judge of whether code works than the model that wrote it. When a task demands a specific length or format, the constraint is parsed out and the output is counted in Python, then rewritten if it doesn't comply, because no language model reliably counts its own output. It scored 100% on the graded set, and 31 out of 32 on brand-new tasks it had never seen — written from scratch, not reworded. That second number is the harder test, and the one that shows it generalizes rather than memorizes. It also holds up when things break: dead endpoints, malformed replies and oversized inputs still produce a valid, complete answer for every task, and a deadline guard guarantees results come back in time. Nothing is downloaded at runtime, and nothing is hardcoded — every answer is produced live. Cuts were all fat — the intro clause, repeated "at all"s, a redundant sentence in the accuracy paragraph. Every substantive claim survived.
13 Jul 2026
