Llm on t0ul

Walk away, read it over coffee

Mon, 19 Oct 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. This is the last one, and it is the mode the whole cockpit was pointed at: the overnight blind campaign. Code in t0ul/GORED; write-ups in t0ul/ai-security-engineering.

Intro

Here is the honest advantage of a tester that runs on my own laptop. It is not that it is smarter than a cloud model, because my GORED series is clear that it is not. It is that it costs nothing per hour and never gets bored. A frontier model billed by the token is a thing you ration. A small model running locally is a thing you can leave on all night, pointed at a problem, for the price of some electricity.

You're not first, and here's the lever

Sat, 17 Oct 2026 00:00:00 +0000

Part of my GORED series, where I point small local language models at my own web apps and measure, honestly, whether they can break them. The harness is t0ul/GORED and these write-ups live in t0ul/ai-security-engineering. Every number comes from a kept, hash-verified trace.

Intro

By the end of the zeros I had talked myself into two bad conclusions at once: that I had built the thing wrong, and that the idea was dumb to begin with. Both felt true at two in the morning. Neither is, and the thing that convinced me was sitting in the research the whole time, which I should have read first instead of last.

The one time it worked, and the exact line where it stops

Fri, 16 Oct 2026 00:00:00 +0000

Intro

I have shown you a lot of zeros. I owe you the one time it genuinely worked, because it did, and it is the most instructive moment in the whole project. A small local model, running on my laptop, wrote a working SQL injection against a login form, watched its first try bounce off, and then corrected its own syntax and got in. That is a real thing a model did, scored by the application itself, not by me.

The one half of pentesting small models are good at

Thu, 15 Oct 2026 00:00:00 +0000

Part of my GORED series, where I point small local language models at my own web apps and measure, honestly, whether they can break them. The earlier posts are a pile of zeros on the exploit side. This one is the part that worked, and it changed how I think about where these models belong. The harness is t0ul/GORED. Every number comes from a kept, hash-verified trace.

The wall: a 3B won't aim its tools, and more tries don't fix it

Wed, 14 Oct 2026 00:00:00 +0000

Intro

The last post left me with a clean, almost hopeful diagnosis. The tools work and the target is vulnerable, so the only thing missing is aim. Aim felt fixable. If the model keeps reaching for the wrong tool, I thought, I will just take the wrong tools away. Give each endpoint only the tools that make sense for it, shrink the decision down to almost nothing, and the model has no choice but to do the right thing.

The ceiling check: is it the tools or the model?

Tue, 13 Oct 2026 00:00:00 +0000

Intro

After enough zeros, you start to doubt your own equipment. I kept pointing the model at my app and getting nothing back, and the honest question at that point is not “why is the model so bad,” it is “are you certain the thing you built even works?” A run that comes back empty because the model failed and a run that comes back empty because the harness is broken look identical from the outside. Both are zero.

Scoring a model attack without fooling yourself

Mon, 12 Oct 2026 00:00:00 +0000

Part of my GORED series, where I point small local language models at my own web apps and measure, honestly, whether they can break them. The first post set the two rules, no cheating and no hardcoding. This one is the plumbing that enforces them. The harness is t0ul/GORED. Every number I quote comes from a kept, hash-verified trace.

Intro

In the last post I said a benchmark you can fool is worse than no benchmark. This post is me showing you I cannot fool this one, because I tried, and it caught me.

Can a local LLM pentest your own app?

Sun, 11 Oct 2026 00:00:00 +0000

Part of my GORED series, where I point small local language models at my own web apps and measure, honestly, whether they can break them. This first post is all setup: the weapon, the target, the ruler, and the two rules. The harness is t0ul/GORED and these write-ups live in t0ul/ai-security-engineering. Every number I quote comes from a kept, hash-verified trace.

Intro

I had a question that would not leave me alone. We keep reading that language models can hack now. There are demos, there are leaderboards, there are papers with impressive single numbers. So I wanted to know the version of that claim that actually matters to me, a person who ships small web apps: can a model I run on my own laptop, with no cloud, no frontier API, find the security bugs in an app I wrote, the way a human reviewer would?

A factory I wouldn't fake

Mon, 05 Oct 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. Last time I gave runs a durable home so they survive a restart. This post is about the one surface I refused to fake, and what it took to make it real. Code in t0ul/GORED; write-ups in t0ul/ai-security-engineering.

Intro

Every cockpit wants a factory behind it, and EVA’s is Studio: the place the skills a run is built from are meant to be authored, tried, and saved. I built it, and then for a while I would not let you save. You could list every skill, read it, pick it, and the edit button was not there, on purpose. That restraint is the first half of this post, because it is the same standard I hold every number in this project to. The second half is the payoff, because the piece that was missing has since landed, and the editor is real now in the one way that matters: a skill you change actually changes the next run.

A sortie log that survives a restart

Mon, 21 Sep 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. Last time I streamed a live run to the browser by tailing its trace. This post is what happens when those runs pile up and I want them to survive a restart. Code in t0ul/GORED; write-ups in t0ul/ai-security-engineering.

Intro

Once I could watch a run, I started doing a lot of them. Different models, different prompts, the same target, trying to build a feel for what moved the needle. And every one of them left a trace file in a directory, which was fine, but the cockpit’s sense of what runs existed lived in memory. So the first time I restarted the server to ship a change, my whole afternoon of sorties vanished from the list. The traces were still on disk, but EVA had forgotten they happened.

Watching it think

Mon, 07 Sep 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. The last post was the seam that lets a piloted run and a headless CI run be one loop. This one turns the dial down and actually watches a run go. Code in t0ul/GORED; write-ups in t0ul/ai-security-engineering.

Intro

My first run page was embarrassing. It used a meta refresh, the old trick where the page reloads itself every couple of seconds, and watching a run through it felt like watching a kettle by blinking. You would catch the state at two-second strobes, the page would jump to the top on every reload, and a fast run would be half over before the first refresh landed. It worked, in the sense that the numbers were eventually right, but it was no way to watch a model think.

LLM proposes, human disposes, on a dial

Mon, 24 Aug 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. Last time I made the case that EVA is a thin window over the one engine my command line and CI already run. This post is about the seam that lets a human-piloted run and an autonomous CI run be that one engine. Code lives in t0ul/GORED; write-ups in t0ul/ai-security-engineering.

A cockpit for the red-team runs

Mon, 10 Aug 2026 00:00:00 +0000

Part of my EVA series, where I build the cockpit I pilot GORED runs from. GORED is the harness that points small local language models at my own web apps and measures, honestly, whether they can break them; EVA is the web surface I drive it from. The harness and the cockpit both live in t0ul/GORED, and these write-ups live in t0ul/ai-security-engineering. Every run EVA shows you is a kept, hash-verified trace.