Open source · Apache 2.0 · 100% free

Your agent writes code fast. The process is what is missing.

Dilux Agentic Workflow is a development pipeline your agent has to walk through: six phases in order, gates it cannot talk its way past, auditors that did not write the code they review, and state that survives closing the terminal.

A rule written in a prompt is a promise; a rule enforced by a hook is a guarantee.
One artifact per phase — PRD, spec, threat model, report — committed to your repo.
Works with Claude Code, Codex CLI, Copilot CLI, Cursor, Gemini CLI and OpenCode.

Start FREE View the repository

It is 100% free and always will be: no paid edition, no SaaS, no account to create.

The six pipeline phases and the gates between them

The problem

With an agent, the same three things always happen

None of them is fixed by writing a better prompt. They are structural, and structure is what fixes them.

It skips ahead

Straight to the implementation, before anyone agreed on what was being built.

It forgets

Forty messages in, the decision you made an hour ago is gone, and the code drifts away from it without anyone noticing.

It drowns

Give it forty rules and it will follow the ones that happened to stay near the end of the context window.

And none of it is auditable

Six months later nobody can say what was decided, why, or against which spec it was built.

How a request flows

You ask in plain language. The machine decides what is allowed right now.

You never invoke a phase by hand. Every arrow needs your explicit approval, and each phase commits what it produced as it closes.

01
CLASSIFY
Works out what you are asking for, reads your stack, opens a ticket and a branch. You confirm the classification.
02
DEFINE
The what and the why: the PRD. It takes the one you already have — a ticket, a doc, a paragraph — and validates it against the codebase.
03
PLAN
The how and what could go wrong: the spec and a threat model. Gate enforced by a hook: no approved spec, no code.
04
CODE
Implemented block by block, each with its tests. Gate: suite green, SAST clean.
05
VERIFY
An agent that did not write the code cross-checks it against the PRD and the spec, and writes the verdict to a report. If it fails, back to CODE.
06
RELEASE
CHANGELOG, pull request, ticket, closeout. What happened is written into the repo history, not into a chat.

The distinction it all rests on

Promise versus guarantee

Before every write, code outside the model reads the state and refuses two different things: a transition the graph does not carry, and a write of product source from a phase that forbids it. There is no talking past it, because the decision never reaches the model at all.

Six phases, one at a timeEach with its own rules, its permitted actions and an explicit list of what is forbidden.
Gates enforced by codeA hook outside the model refuses the illegal transition. Not a convention: a refusal.
State on diskIt survives closing the session. The machine knows where you left off.
Rules loaded lazilyOnly the current phase’s instructions enter the context.
Tiers, so it stays proportionateFixing a typo cannot cost you a PRD: QUERY, QUICK-FIX, FIX, FEATURE and DISCOVERY get different pipelines.

Security

Security is a phase, not a footnote

Two controls, at two moments, each catching what the other cannot. Both produce a report, not just a flag — including what you dismissed and why.

Threat modeling in PLAN

Looks at the design before it exists. Blind to implementation bugs — which is exactly what the other control sees.

SAST in CODE

Looks at the code without running it. Blind to business logic and authorization — which is exactly what the threat model saw.

Independent audit

The VERIFY phase is run by an agent that did not write that code. Nobody reviews their own work.

It all stays in the repo

PRD, spec, threat model, SAST report and verification report live under docs/, committed phase by phase.

In action

This is what it looks like when the method runs

Real captures of the pipeline working on a repository: the phase diagram, a gate closing, a hook refusing a write, and a phase closing with evidence.

Diagram of the DAW pipeline with its six phases and the gates between them — The whole machine **Six phases, and between each one a gate you have to satisfy** From IDLE to RELEASE and back. Every phase produces its artifact — ticket, PRD, spec, code, report, PR — and every arrow needs your approval. The orange padlocks are hook-enforced gates: they are not model promises.

Terminal showing the DAW hook blocking a source code write — The gate, live **The hook refuses the write, and there is no talking it round** A real test: the agent is asked to write code while in the DEFINE phase. The hook blocks the Write before it reaches disk and returns the reason. “Nothing was written to disk”: that is the difference between a promise and a guarantee.

DEFINE phase closeout summary with a validated PRD — Phase closeout **The PRD validates, or the phase does not close** DEFINE closes with a verifiable summary: functional and non-functional requirements, acceptance criteria, affected modules and a validation that passed 14 checks. Only then does it ask whether to move to PLAN.

CODE phase closeout with tests and security analysis passing — Quality and security **Suite green and SAST clean, with a report** CODE does not close on an opinion: it closes with per-block architecture audits approved, 14 tests with evidence of prior failure (real TDD) and a security analysis with no critical, high or medium findings.

Everything you see here gets committed to your repository, phase by phase. Six months later someone can read why it was done this way.

Pricing

This one is easy: it costs nothing and there is no better version waiting behind a paywall.

The only edition

Open source

The whole framework

FREE · forever

Apache 2.0 license
Installs into your repository, not your machine
Six agents supported, one method
Idempotent installer: reinstalling is upgrading
Clean uninstall that respects what you made yours
No account, no signup, no telemetry

View the repository

Installation and configuration are on you, at your own risk.

Need a hand?

Optional services

Custom

Rolling DAW out across your repos and teams
Customizing phases, gates and auditors
Training your team on the full method
AI development maturity assessment

View consulting

Private preview

Start free today

The framework is already published: you can clone and install it right now. Leave your details if you want us to support your rollout or notify you on every release.

Free, and no credit card.
We email you as soon as a seat opens.
Meanwhile you can keep using the open source edition.

Frequently asked questions

Does it work with the agent I already use?

It works with Claude Code, Codex CLI, Copilot CLI, Cursor, Gemini CLI and OpenCode. It is one method with six wirings: what changes between them is where each tool looks for its files, never the framework itself.

Does it force me to write a PRD to change one line?

No. CLASSIFY assigns a tier and the tier picks the pipeline. A typo takes the short lane with no PLAN and no VERIFY; a new feature takes the full run. A process that expensive is a process people quietly stop using.

What if I want it out?

There is an uninstaller that shows the plan before touching anything, removes only what is DAW’s and never deletes docs/. The PRDs, specs and reports are the record of what was decided and why: uninstalling the tool is not a reason to lose them.

What language does it work in?

Yours. The repository is written in English, but those files are prompts: the shipped template carries an explicit directive to answer in the language you write in, and to write every artifact in that same language.