noxdev

Agent engineering for production codebases

Accountable AI engineering

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

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.