Every change starts as a written contract, runs as one small task, and carries its own
record from request to merge.
A contract says what to build, which files it may touch, and how we will know it worked. Each one
runs on its own and has to get past two gates before it reaches your review.
Runs on your codebase, in your repo, with your model and your keys.
The bet
The industry is betting on accumulation. We bet the other way.
Every tool in this category is buying reliability with more context: bigger windows, longer
sessions, more state carried forward. Models get worse as their context fills, so the longer a
session runs, the less the work is worth.
The common bet
One long session that carries everything it has learned forward. Reliability
bought with more context, more state, more runtime.
noxdev
One contract, one fresh container, zero context carry-over. Only the committed
code and the audit's gap list pass forward. The thousandth task is as sharp as the first.
Everything else about the product falls out of that one choice. Because the
work is decomposed into contracts before anything runs, each unit has a specification that can be
checked, a file scope that can be enforced, a reviewer that is forbidden to edit code, and a record.
How the work moves
From intent to a pull request you can actually review
One feature, end to end
1
Intent arrives
A feature request in plain English, from a roadmap item or a ticket.
2
Grounded in the code graph
Files, calls, imports and the owning module, read from the repository as it is today.
as-built graphowning modulearchitecture review
3
Decomposed into contracts
A dependency graph of small units. Each one declares its specification, the files
it may touch, and the check that proves it worked. This happens before a single build token is spent.
SPECFILESVERIFY
4
Estimated before it runs
The same decomposition that makes the work reliable is what makes it priceable.
You see the cost of the feature before you approve it.
5
Each contract runs alone
A fresh container per contract. Nothing from the previous one is in scope.
6
Gate one: the test has to fail without the change
We take the change back out and require the test to fail. If it still passes,
that test was never testing anything.
proven to failheld back
7
Gate two: the edits stayed inside the declared files
Every contract declares its file scope up front. We verify the diff never left it.
diff scope clean
8
Clean-eyes re-audit
A new container and a different model read the result adversarially and produce a
gap list. Misses go back through the loop and get fixed inside the same run.
gap listfixed in-run
9
A pull request in your repo
Under your review and your CI, with the lineage attached: the roadmap item, the
specification, the commit, the verdict and the dollar.
The two gates
A passing build is not evidence
When an agent writes the code and also writes its tests, a green build tells you
nothing. It marked its own homework.
Gate one
The test must fail without the change
Before anything is accepted, the change comes back out and the test has to fail. A test that
passes either way was never testing the change. This is the cheapest way to tell real work from
work that only looks finished.
Gate two
The diff must stay inside the declared files
Every contract names the files it is allowed to touch before it runs, and the diff is checked
against that list. An agent that wanders is how a small feature turns into a review nobody can do.
We have not found another tool in this category that runs either one.
Evidence
It has been writing our own software since March
noxdev runs unattended on our own production codebases and we read the reviewed results in the
morning. Every contract it has run is in the ledger, with its gates, its diff and its outcome.
Why the units stay small
The ledger is also what settled the design. The more files a contract is allowed to touch, the
more often it fails, and the curve is steep enough that it decided the question for us. Small,
contained units are not a style preference, they are what the failure curve asks for.
How it fits
Your codebase, your rules
Runs on existing codebases in any stack, including the ones nobody wants to touch.
Enforces your architecture as it is, instead of imposing a template.
Delivers pull requests into your repository, under your review and your CI.
Your harness, your model, your keys, your infrastructure. Self-hosting and bring-your-own-model are the default, which is what FINMA, DORA and the Cyber Resilience Act end up requiring anyway.
Every unit is recorded, so the cost of a feature comes out of the lineage for free.
We are looking for design partners
Teams with a real production codebase and work they would rather not do by hand.
You get the engine on your repo and a direct line to the two people who built it.