← Anwar Debes The long film

Shorts

One project in about 40 seconds: what it does, what the numbers say and where they fall short. Every number is sourced in the long film Show Its Work.

01 · 34 s

AI coding agents keep deleting files. This tiny guard says no

A tiny Tsetlin Machine checks every command an AI coding agent proposes before it runs, and shows the readable rule behind each block. Demo replay: the agent is scripted, the guard's decisions are computed live. Prototype trained on synthetic data: 97.7% on 129 hand-written tests, not yet tested on real agent logs.

02 · 37 s

Negative result: my AI model lost 27 points, BERT lost 2

My Tsetlin Machine (a model built from readable yes-or-no rules) against BERT on 488 movie reviews that people rewrote to flip the sentiment (Counterfactual IMDb, Kaushik et al., ICLR 2020): 90.0% to 62.9% for mine, 90.4% to 88.1% for BERT. One seed, one dataset; BERT's clean score is on a 1,000-review subset.

03 · 40 s

I asked a math solver to break my AI guardrail

A SAT solver checked my prompt-injection guard against every combination of its 256 word features, found a bypass in under a second ("Which ignore previous instructions"), then proved a one-rule repair. The proof covers words, not meaning.

04 · 40 s

This AI has no neurons: the Tsetlin Machine explained

A Tsetlin Machine learns rules you can read instead of neural-network weights.

05 · 38 s

Every email looked innocent. The AI agent session wasn't.

A per-call filter allowed every email this simulated AI agent sent. TRACE watches the whole session and blocks the third outside email, with rule checkers that fit in 322 bytes.

The agent is simulated (scripted tool calls); the guard, monitors and ledger are real.

06 · 44 s

My AI research made 91 predictions. Only 15 came true.

My master's research asks whether a language model can be built from rules you can read. Before each test I wrote down the prediction, the metric and the pass mark: 15 of 91 came true, 14 failed, 5 were not judged, 57 never ran. One study, one seed for the main test, real data, no paper yet.

07 · 44 s

Zero attacks got through my AI agent guardrail. Here's the catch

clausegate reads every tool call an AI agent wants to run as three graphs (action, context, policy) and answers allow, deny or needs a human, with a signed receipt. No attack was approved, but only 30% of honest calls were approved outright; the rest went to a human. On tools it had never seen, every call went to a human: zero again, but this time all deferral, no detection.

Scope: a train/test split of AgentDojo-derived tool calls (5 seeds, 80/20), not the official end-to-end AgentDojo benchmark. Research prototype, draft paper.

08 · 41 s

Explainable AI: can a network certify its own explanation?

Most AI explanations are written after the fact. CANDOR builds one in: a layer runs through named concepts, keeps what they miss as a measured leak, and every answer gets a certificate, delta.

Small synthetic tasks and a one-layer Transformer; preprint, not peer reviewed.

09 · 45 s

An AI denies a loan. What's the smallest change that flips it?

My prototype CCTM (a Tsetlin Machine: a model made of rules you can read) searches for the smallest feature change that flips a loan decision, and writes a receipt that can be re-checked without the model. On synthetic loans with a built-in gender bias, training on one-feature "twins" cut the approval gap from 0.18 to 0.04 on average over 3 seeds; in one seed the twins barely helped.

The catch: the twins were labelled by the bias-free rule that generated the data, and real data has no such oracle. Synthetic data only; draft paper (v0.1), not peer reviewed.

10 · 41 s

Blocking an unsafe AI agent kills the task. Repair the action instead

A blocking guardrail stops an unsafe AI agent action, and the task dies with it. REINS, my runtime guard, tries the edits the deployment allows (add a missing step, swap in a safer tool, drop the call, ask a human) and applies the cheapest one that keeps the policy safe. On my synthetic benchmark (12 seeds, 60 honest and 60 attack tasks per seed) both stopped every attack; blocking finished 32.8% of the honest tasks within the rules, REINS 100%.

That 100% is a best case: the steps these tasks forget are exactly the ones REINS is allowed to add, and without the audit insert it finishes 66.9%. Synthetic tasks, not a live agent. Draft paper.

11 · 46 s

My ARC-AGI-3 agent didn't beat random. My preprint says so.

LUCID is my glass-box AI agent: it plays turn-based games it has never seen, with no instructions, no neural network and no GPU, learns its own readable rules for each game and logs the rule behind every move. On the 25 public ARC-AGI-3 games it scored 0.083% RHAE against 0.095% for random moves, one run each. It does not beat random.

Scope: the public development games, not the official leaderboard; up to 300 actions per game for LUCID and 200 for random; preprint, June 2026.

12 · 39 s

My AI model flagged a molecule. Then it named the bond to cut

A Tsetlin Machine (a model built from readable yes-or-no rules, taught by a GIN neural network) flags a molecule as mutagenic on the TDC AMES test set, then proposes a small graph edit, up to 3, that flips its own prediction: 191 of the first 200 molecules it flagged, 1.30 edits on average. Real data, scaffold split, 729 test molecules, 5 seeds.

Two catches kept in: a fingerprint random forest still predicts better (AUROC 0.790 against my 0.685), and in case 1 the proposed edit detached a carbon while my validity check reported it valid. A flipped prediction is not proof the chemistry changed. Draft paper; not drug-safety advice.

13 · 40 s

I changed one line in a copy of my AI agent's log. It got caught

In Glassbox Studio a small rule-based guard checks every tool call an AI agent proposes, and each decision goes into a ledger where every entry stores a SHA-256 fingerprint of the entry before it. The page's Tamper test edits entry 9 of an 18-entry ledger in a copy, and the check fails at that entry.

The catch: the chain is not signed, so whoever can rewrite the whole ledger can recompute every fingerprint and the check would pass. Prototype; the agent's words are scripted, the guard decisions and both checks are computed live.

14 · 45 s

I retrained my AI guardrail on its own failures. It got worse

A solver (z3) checked 8 must-block words on 8 small prompt-injection guards: 54 of 64 checks failed. After 8 rounds of retraining on those failures, 64 of 64 failed and test accuracy fell from 69.2% to 56.5% (mean of 8 seeds). Hard-coded rules on the starting guards instead: 0 of 64 failed.

The price: those rules block every prompt containing one of the words, one of them is "write", and no harmless test prompt contains any of them, so test accuracy cannot show that cost. Tiny guards, one dataset, 8 seeds, draft paper.

15 · 44 s

I traded 1.5 points of accuracy for an LLM router I can edit

My LLM router is built on a Tsetlin Machine: 4,000 rules vote on where each question goes, and a question with a low vote margin goes to a human instead. On CLINC150 it routes 94.17% of questions correctly (mean of 5 seeds); logistic regression on the same embeddings gets 95.64%. In my edit test, one added rule lifted play_music from 80% to 90%.

The simple baseline is ahead on accuracy, on Banking77 and at spotting off-topic questions. Only 3 of 15 attempted edits improved the test set. Technical report, not peer reviewed; the dataset loaders are not in the repository yet.

16 · 43 s

Hot car simulation: cracked windows bought zero extra minutes

A physics simulation, not AI: a dark sedan parked in full sun on a 34 °C day, with a toddler inside. With the windows cracked, the cabin peaked less than one degree cooler, and the simulated toddler reached the model's heat stroke line (core 40 °C) in the same 1.5 minute time step: zero extra minutes. Across all 168 simulated cases, the median was also zero.

The catch: the window effect is an input based on a 2005 study of one real car, and the 16 published checks test the cabin model, not the body model. A simulation, not a safety device. The one option the results mark as guaranteed safe: never leave a child in a parked car.

17 · 44 s

I built a test my AI model wins. On real data, the win disappeared

Negative result. I built a synthetic test that adding up votes can never get fully right, and my rule-based model won it: 96.8% against 72.7% test accuracy (5 of 5 seeds). On real data, Breast Cancer Wisconsin with 3 views, the win disappeared: 92.8% against 92.5%, a difference of +0.003 (95% CI -0.006 to +0.012, one-sided Wilcoxon p = 0.233); 2 wins, 2 losses, 1 tie.

One real dataset, 5 seeds; the draft paper calls the two statistically indistinguishable.

18 · 37 s

I gave my AI coding agent a face

Pixie is my open-source AI coding agent: it runs on your own machine with the model and API key you choose, and instead of a spinner a pixel creature acts out each step (reading, searching, typing, editing). Before it edits a file or runs a shell command that is not read-only, it holds up a question mark and waits for your approval, and the harness enforces that, not the model.

The video shows the live demo, which replays a recorded session in the real interface: the tool output is real, the model's replies were scripted. A face shows what the agent does, not why.

19 · 44 s

How many bit flips change an AI's answer? Mine counts them

RobTM tries every single bit flip, then every pair, then every triple of a Tsetlin Machine's 10 yes/no inputs, reports the fewest flips that change its answer, and refuses to answer when that number is below a threshold. The honest result on a synthetic task: one flipped bit changed 276 of 277 correct answers; with the refuse rule at 2 flips it answered 3 of 360 cases, 2 of them right.

Training on flipped examples did not help (272 of 273 still fell to one flip). Prototype and draft paper v0.1, synthetic data only, exact search up to 3 flips.

20 · 38 s

Can you fact-check a 49-minute film? Mine lists all 541 sources

Every source my film Show Its Work puts on screen is an entry in a public ledger, each hashed and chained to the one before: 541 entries, 505 of them a file at a pinned commit, 495 of those down to the line. One command, node verify-ledger.mjs, clones every cited repository fresh, re-hashes every source and prints the head hash; the clip shows the recorded run of 31 Oct 2026 (64 repositories, 67 pinned commits, all 541 matched).

The catch: the ledger shows where a number came from, not that the number is right, and the chain is hash-linked, not signed, so anyone can recompute it.

Narration: synthetic voice. TikTok · YouTube