You hear knocking in the basement.
Tell your chat.
Get it built.
Knockmill turns the AI you already use into the operator of an independent software factory. You describe what you want. Knockmill builds it, reviews it, proves it — and hands back the result.
Not just apps
Knockmill builds anything that's supposed to work: tools, scripts, libraries, fixes, rebuilds. Throw in broken code and say make it work. Throw in a half-finished project and say finish it. Where a single AI patches and hopes, the factory builds, reviews, and judges — in rounds, until it holds.
Why people trust it
Stay in your chat
Connect Knockmill once. After that, just talk to the assistant you already use. No new app, no dashboard, no tutorial.
Nobody grades their own homework
One AI builds. A second one tries to break it. A third one judges — against your wishes, written down and frozen before work starts.
Receipts, not vibes
Every delivery comes with proof: what was checked, what was found, what was fixed. When something is unclear, the factory stops and asks — it never guesses.
Your models. Your subscriptions.
Knockmill uses the AI plans and APIs you already have — across vendors. We sell the factory, not another bucket of AI credits.
Already live in a coding agent? Stay there.
Knockmill speaks MCP — plug it into Claude Code, Codex, or any agent CLI, and your coding agent becomes the operator. Hand over the work you'd never trust to a single model: the big refactor, the rewrite, the adapter against the legacy system. Your agent keeps building alongside while the factory grinds it out in rounds. Not “looks good to me” — a verdict backed by evidence.
Two ways to run it
Hosted
Just connect and build. We run the factory; you bring the wishes and the AI plans. This is what early access opens first.
Self-hosted
The factory comes to your infrastructure. Your repositories never leave your machines — built for developers and teams who keep their code close.
The system you are using
was built by the system you are using.
Every feature shipped through Knockmill’s own pipeline — hundreds of documented orders, each with rounds, findings, and a verdict. And where a human hand stepped in, that is on file too, with the reason named. The chronicle kept the record — interventions included.
And it keeps going. The factory learns from every run and can rebuild itself: order a change to your own mill — its rules, its roles, its review standard — and the same three workers build it, review it, and prove it, with every version kept so you can step back to any state that worked. The factory core stays one version for everyone; that is how fixes reach you the night they land.
From the build log
Where the tokens go, and what we are building so fewer do
The judge and the reviewer are cheap. The builder is not, and not because it builds. It re-reads. Here is what we measured, what we changed, and the three things still on the bench — with the numbers, because the customer pays for every token.
week 38: 1 orders · 1 approved · 0 escalated or aborted · 0 operator interventions
on file: 263 orders since July · 204 approved · every one with rounds, findings, verdict
See the architecture: three heads, one door → — an interactive map, built from a typed spec, not from a screenshot.
Early access
The factory is running — it built its own order counter, and the first outside operators are connecting. We're opening the doors gradually, no launch date promised.
Want us to knock when it's your turn? Leave your address:
For the curious
The machinery behind the counter, for those who like to look inside.
Builder
Implements your order in an isolated worktree — code and tests, nothing else. No shell, no free network access, no scope creep.
Reviewer
Reads nothing but the code. Verifies every claim independently and files findings with evidence — it never trusts the builder's word.
Judge
Rules against your frozen acceptance criteria, literally. Approve, another round, or escalate to you instead of guessing.
- Frozen criteria. The goalposts are written down before the first line of code and cannot silently move.
- Escalation over guessing. Contradictory orders, wrong premises, missing capabilities — the workshop stops and asks instead of improvising.
- A chronicle, not a vibe. Every run leaves a machine-readable record: rounds, findings, escalations, escaped defects. Quality you can audit, not just believe.
- What is tested is what ships. Verification runs against a fresh materialisation of the delivered state — an invisible helper file can’t sneak a green run past the gate.
- Memory is first-class. Workers remember earlier findings, precedent rulings, and build patterns across runs — every failure becomes a guard.
The factory remembers
Every project carries a real memory — findings, verdicts, and lessons from every run, retrieved by meaning and by keyword, re-ranked, and fed to each worker only when it is confident it belongs. Reset your code to an earlier version and the memory follows: knowledge about the code steps back with it, experience stays and is marked for the line it came from. That is why the second order on your project is better than the first — and the fiftieth better than the second.
Hybrid retrieval
Every finding, verdict and lesson is indexed twice — by meaning (embeddings) and by exact words (BM25) — merged, then re-ranked by a cross-encoder so the passage that actually answers the question comes first, not the one that merely sounds alike.
The inlet
Before each worker turn, the memory is searched for that turn’s question and the relevant passages are placed in front of the worker — only what retrieval rates relevant, and never the same passage twice. No worker has to remember to look things up.
Rolling context
Long builds do not lose their thread: when a worker’s window fills, the oldest completed segment rolls out of the window into memory, where it stays searchable — the frozen order and criteria stay pinned. The window never silently truncates.