A factory line where every station inspects the last station's work. One agent builds. A second agent grades it. Defects die on the line — they never reach you.
Imagine a bakery where nobody tastes anything.
The bread goes straight from the oven to the customer.
Some loaves are perfect. Some are raw in the middle.
The customer finds out. Not the baker.
That's how most people run AI agents.
The agent writes the code, the article, the page — and hands it straight to you.
Nobody checked it.
So you become the inspector.
You read every output. You test every build. You catch every broken button.
You wanted a team. You got a pile of homework to mark.
And the moment you stop checking, slop ships.
The Self-Checking Factory breaks that cycle for good.
If you can type one sentence and pick two things from a dropdown, you can run this.
The whole factory is a text box, a Builder menu, a Judge menu, and one Run button.
Here's the whole idea in one line: the agent that builds the work is never the agent that grades it.
Why? Because AI is a terrible judge of its own work — the same way you can't proofread your own writing. It reads what it meant to write, not what it wrote.
So the factory splits the job in two.
A Builder makes the thing. A separate Judge scores it out of 100 against your goal. If the score is too low, the work goes back down the line with the judge's notes attached. The Builder fixes it. The Judge scores it again.
The loop only ends two ways: the work passes, or it stops improving and the factory tells you honestly.
The judge doesn't need to be perfect. It needs to be separate.
A separate grader with your goal in hand catches the obvious slop — broken buttons, missing sections, ignored instructions — which is 90% of what wastes your time.
Here's a real run from my own machine — an ROI calculator I asked the factory to build. No theory, this happened.
You type the goal. One sentence in a text box: "Build an AI automation ROI calculator." That sentence becomes the spec the judge will grade against.
The Builder makes draft one. A free model writes the whole thing as one self-contained file. Free models are sloppy on the first pass — that's fine, the factory expects it.
The Judge grades it: 8 out of 100. A different model reads the goal, reads the draft, and scores it. Draft one was mostly broken. The judge said so, in writing.
The return belt runs. The draft goes back to the Builder with the judge's notes attached: what's missing, what's broken, what to fix.
Round two: 85 out of 100. The Builder fixed the big problems. Still not passing. Back down the belt it goes.
Round three: 100 out of 100. The judge signs off. The loop ends.
The work ships to a shelf, not a chat. The finished build saves to a Builds workspace on disk and to my vault — with a live preview. I saw it for the first time when it was already done.
So when someone asks "but what IS it?" — it's a loop where a second AI grades the first AI's work against your goal, and nothing reaches you until it passes.
The whole system runs on one thing most people skip: a clear goal.
The judge can't grade "make something cool." It CAN grade "a countdown timer with a date picker, a live preview, and no broken buttons."
Your goal is the order form the factory works from. Every station reads it.
Three rules for writing one:
Name the finished thing. "A pomodoro timer page" — not "help me with productivity."
Name what "working" means. The buttons it needs, the sections it needs, the result it produces.
Keep it one paragraph. The judge grades against every line you write. Short and sharp beats long and vague.
Every version of this — the loop, the kanban board, an agent team — is the same five stations in a row.
Your goal, written like an order form. This is what every station checks against — so you never have to explain "what good looks like" twice.
The agent that makes the first draft. It never grades itself — so its blind spots never become your problem.
A second, separate agent scores the work out of 100 against your order. You get a number and written notes, not a shrug.
Failed work rides back to the Builder with the Inspector's notes attached. The redo happens automatically — you're not in the loop, and that's the point.
Only passing work gets through. It lands on a shelf — a Builds workspace, your vault, a live site — finished and previewed, ready when you are.
Loop Engineering is the factory at its smallest: one Builder, one Judge, one text box. This is the panel in my Agent OS.
What you're looking at: the real Loop panel. A goal box, a Builder menu (a free model), a Judge menu (a free local model), max rounds, one Run button — and below it the Builds workspace, where four finished, judge-passed builds sit with live previews.
Three choices, then you press Run:
Pick a Builder. A free model is fine here — the loop exists precisely because first drafts are weak. The redo rounds do the polishing.
Pick a Judge. Mine defaults to a free model, with a local offline model as backup. The judge reads the goal, reads the build, returns a score out of 100 and notes. If the free judge ever flakes, the local one takes over so the loop never stalls.
Set max rounds. Four is my default. The loop also stops early if two rounds in a row don't improve — so it never spins forever pretending to work.
Everything that passes lands in the Builds workspace on disk and logs to my vault. The chat is not the product. The shelf is.
Weak at drafting, fine at redoing. That ROI calculator scored 8 on draft one and 100 by round three — same free model, guided by the judge's notes.
One honest limit: free endpoints throttle on big batches and complex games. For one tool, page, or app at a time, the free loop holds up.
The loop is one worker and one inspector. The kanban board is the full factory floor.
Three agents share a live board: a Planner breaks your goal into cards, a Builder builds each card, and a Reviewer checks every build before it's allowed into Done.
You watch cards move: Backlog → Building → Review → Done. The Review column is the whole trick — nothing skips it.
And it's not a toy. I flipped my board to SEO mode, gave it one topic, and the team planned a five-article cluster, wrote every article, and shipped them to one of my live sites — real pages, deployed.
What you're looking at: the board's Workspace shelf — 16 finished builds saved on my Mac, including the real SEO articles the team wrote and shipped to my live site. Every one of these went through the Review column first.
The cards don't care what's on them. Mine have held web tools, SEO articles, and landing pages in the same week.
If your work can be described in a sentence and checked against that sentence, it can ride this board.
You check better — on the one thing in front of you. The judge checks every draft, every round, at 2am, without getting bored.
Keep your judgement for the final 5%. Let the factory eat the other 95%.
No — that's the biggest myth about it. The everyday 90% runs on free local models on your own machine, and free APIs slot in for more — this whole guide's judge costs $0.
For the frontier work, the Agent OS drives the CLIs you already pay for — your Claude subscription already includes the Claude Code CLI, and the OS plugs straight into it. You're not paying twice; it's a layer on top of what you already own.
And inside the AI Profit Boardroom there are full token-optimisation tutorials, so usage drops even further and you never think about it again.
Wrong: "AI output is unreliable, so I have to check everything myself forever."
Right: Unchecked AI output is unreliable. A separate judge grading every draft against your goal is exactly the reliability layer you've been doing by hand.
Wrong: "Self-checking agents need expensive frontier models."
Right: The judge in this guide is a free model with a free local backup. The loop's redo rounds are what create the quality — not an expensive builder.
Wrong: "I'll set this up later, when agents settle down."
Right: The people building checking systems now compound every new model release. Every better builder that ships drops straight into a factory that already grades it.
Members post their wins every day — agency owners, ecom founders, course creators, solo operators across 38 countries. Real businesses, real numbers, in their own words.
Read the 158-page wins doc →This isn't a concept page. The loop panel and the board in the screenshots above are the ones running on my machine today — the same system behind my agency and channel.
Write one goal. Name the finished thing and what "working" means. One paragraph.
Split builder and judge. Whatever tools you use, the rule is the same: the AI that makes it never grades it.
Make the judge score out of 100. A number forces honesty. "Looks good" is not a grade.
Make the judge write notes. The notes are the redo instructions — that's what the return belt carries.
Cap the rounds. Four rounds max, stop early if two rounds don't improve. No infinite spinning.
Ship to a shelf, not a chat. Passing work saves somewhere permanent with a preview — a folder, a workspace, your vault.
Run it on one small build. A timer, a calculator, one article. Watch the score climb. Trust comes from watching.
Then scale to the board. Same trick, three agents: Planner fans out cards, Builder builds, Reviewer gates the Done column.
One goal, free builder, free judge. Watch a score climb from failing to passing without you.
Write tighter goals. Watch how a sharper spec makes the judge stricter and the output better.
Move from one loop to the kanban team. One goal → five cards → every card through Review.
Point the board at real work — articles, pages, tools — and let the Ship Gate deploy it live.
A separate judge grades every draft out of 100 — before it reaches you.
The judge is a free model with a free local backup. $0 per inspection.
The judge's notes drive the redo automatically. No more "actually, fix this" chats.
Everything that passes lands on a shelf with a live preview — not in a chat scroll.
Planner, Builder, Reviewer — and nothing enters Done without passing Review.
Every new model that ships drops into a factory that already checks it.
