Quox Dev Suite · DoneEngine
The flag drops when the evidence says so. Not when the agent does.
DoneEngine is the instrument in the toolbox that reads the plan and the evidence and answers, per surface and per organisation, is this actually done, and on what?
Verdictsclear · refused · unknownFinish linesbuilt ≠ deployedEvidenceattested ≠ machinePostureadvisory, never blocksIn plain words
What it is, where it lives, when to reach for it
- What is it
- A command line tool in the Quox Dev Suite that scores whether work is really finished.
- Where do I use it
- In your terminal, and on the DoneEngine tab of the dashboard's Dev Suite page.
- When would I use it
- When someone says a feature is done and you want the evidence before you ship.
- How do I use it
- Run
quox done check <subject>. It answers clear, refused with reasons, or unknown.
The problem
Green checks lie by omission
An autonomous developer will happily tell you the work is done. A human team has someone who eventually notices it is not; an agentic one does not, unless something independent holds the flag.
A passing suite proves the code, never the deployment. A ticked phase proves someone said so. A status doc proves what was true when it was written.
Each is real evidence, and each has a blind spot big enough to lose a launch in: this instrument exists because our own board once read 10 of 10 while every fix sat committed and unbuilt, and it stayed wrong for two days.
Autonomy makes the blind spot worse, not better. When agents do the work, the entity claiming done is the entity that did the work, and no amount of confidence in the claim makes it evidence.
DoneEngine is a sceptical reader of the evidence that already exists: the maturity maps, the test runs, the running containers, the roadmap. Where the sources disagree, it says so out loud, because a plan that claims done over code that is not running is exactly the thing worth catching.
Where it sits
One loop, four instruments
The autonomous developer's toolbox is a loop, and DoneEngine is its closing move. QuoxPlan owns intent, the agent does the work, ProofLoop turns claims into evidence, and DoneEngine gives the verdict that either drops the flag or sends named reasons back into the plan. The Agent Honesty chain runs underneath all of it.
The plan states what done means: streams, phases, the finish bar.
The model
Four rules, none waived
Built is not deployed
Build Ready is a statement about the repository; Deployed Ready is a statement about the running system. DoneEngine reports both and never averages them, because the gap between them is precisely where shipped work goes missing.
Attested is not machine
A sentence in a status doc is attested evidence: someone said so. A byte-for-byte file comparison inside the running container is machine evidence. The engine reports the two counts separately and has no code path that totals them.
Rule packs are data
A gauge is a JSON pack: gates, subjects, a finish bar. A release bar, a GA bar and a suite bar are different packs on one engine, so anyone can read the rules being applied and argue with them. A second gauge was proven by writing a pack, not by forking the engine.
Unknown is not a pass
No evidence means UNKNOWN, its own verdict with its own exit code. Treating absence as approval is the exact failure this engine was built after; treating it as refusal trains people to ignore refusals. Saying "cannot tell" is the point.
The instrument
One engine, three surfaces
quox done, for agents first
check, board, bar, history, packs. The primary users are agents deciding whether to act, so the exit codes are the contract and JSON mode returns the structured verdict. One engine; the CLI shells out to it rather than reimplementing the rules.
A mirror, not a re-measure
The dashboard panel renders the engine’s newest snapshot and says when the measurement was taken, with a loud staleness warning past 24 hours. It never re-measures: the engine runs where git and docker can answer honestly.
Your roadmap, your readiness
Readings are organisation-scoped: plan evidence is read as your org, snapshots are stamped with it, and the panel serves each org only its own measurements. Proven live with a two-org matrix: the owner org sees its readiness, a fresh org sees an honest "nothing measured yet", never someone else’s numbers.
Driven, not described
Our own suite, judged by its own instrument
This is a real reading of the Quox Dev Suite bundle, taken 21 August 2026. It says 2 of 6, in public, on the vendor’s own promo page, because a readiness board that only ever says yes is decoration. When the bar is met, this transcript is how you will know we did not lower it.
$ quox done bar dev-suite 🏁 Quox Dev Suite readiness FINISH bar: full house definition of done, nothing waived: rated rows, zero Broken, zero Stub, claims live-verified, limits named, cited tests, CLI parity DONEENGINE 58 live-verified yes limits yes BUILD READY yes QLARITY 56 live-verified yes limits yes BUILD READY yes DEV-SERVERS 82 live-verified yes 1 stub BUILD READY no QUOXCLI — live-verified NO limits yes BUILD READY no BUILD READY: 2 of 6 spine surfaces meet the FINISH bar QuoxPlan cross-check (attested, one way): DEVSUITE IN_PROGRESS, 15/17 ticked plan owns intent, DoneEngine owns boundaries; read here, never written
How you get it
It ships with the suite, and it pairs with the plan
In the Dev Suite
DoneEngine rides the Dev Suite bundle alongside the rest of the toolbox: nine members for $169 against $212 bought separately, 20% off. One install on your own QuoxCORE instance, the quox CLI verbs and the dashboard panel included. The platform itself is free during the public beta.
With QuoxPlan
The natural pairing: QuoxPlan owns intent, DoneEngine owns boundaries, and the cross-check between them is where disagreements surface. DoneEngine reads the plan and never writes it, so the separation holds by construction.
On its own
DoneEngine has its own store row at $19 as of 2026-08-28, so you can take the readiness instrument without the rest of the suite. It is the same product either way; the bundle is simply cheaper if you want the other eight.
The mirror, live
The panel, showing us our own unfinished work
- 1Build Ready, 2 of 6: the repository side of the bar, per the pack’s own finish line.
- 2Deployed Ready reads unknown here because this snapshot ran without deploy probes, and unknown is never dressed up as a pass.
- 3When the measurement was taken and which pack judged it. The panel mirrors the instrument; it never re-measures.
- 4Per-surface verdicts: READY only where the maturity map earns it, with the deploy evidence class named beside it.
Captured 21 August 2026 from our own dev instance, logged in, platform healthy. The reading is real and unflattering on purpose.
Honest state
What is real today, what is planned
The instrument that grades honesty gets graded honestly. Everything in the left column has been driven for real on our own stack; the right column is stream DONEENGINE, in the open.
- Two finish lines with the incident that earned them: the instrument once reported 10 of 10 built while every fix sat undeployed for two days, and the split verdict is the fix
- Machine deploy evidence: every tracked source file compared byte for byte inside the running container; caught a real two-commit drift unprompted
- Test-run evidence: the declared suite actually executes and the real pass/fail is recorded against the repo commit, so "cites a test corpus" and "the tests pass" are different gates
- The QuoxPlan cross-check, read-only by construction: plan state is shown beside the verdict, never folded in, and the first run caught a stream marked complete whose surfaces were not running the code
- Rule packs as data with a declared finish bar per pack; the engine refuses a pack that puts a deploy gate in a build bar
- quox done check | board | bar | history | packs, exit codes passed through unchanged
- The dashboard mirror panel with measurement age and honest no-snapshot state
- Per-org readings end to end (21 Aug 2026): org-scoped plan reads, org-stamped snapshots, an org-filtered mirror, live-proven with two organisations
- Append-only snapshots and a history view that lists regressions before gains
- A 53-test regression suite where every group encodes a defect this instrument actually shipped or nearly shipped
- A snapshot cron, so the panel stays fresh without an operator running the instrument by hand
- Repo and deploy evidence for customer codebases (today the machine evidence reads our own estate; a customer org gets its plan evidence and snapshots)
- Whether DoneEngine may refuse a deploy: an open owner decision, and until it is made the instrument stays advisory on purpose
- The store SKU and how it bundles (a QuoxPlan + DoneEngine pairing is the open packaging question)
DoneEngine
Ship on evidence, not on optimism
Part of the Quox Dev Suite. Two finish lines, honest unknowns, and a verdict an agent can act on.