Agent
Do the workAny local CLI agent drops in here — Codex, Claude Code, Gemini. It takes a role, a task and a status you can read.
DNP gives you a canvas and a set of blocks — agents, reviewers, a browser, a terminal, your own tests. Wire them into a run that fits your team, not a template someone else wrote.
Ship the pricing page
Rewrite the pricing table. Keep the plan names and the tone of the current page.
Agent
Do the work
Reviewer
Hold the gate
There is no fixed set of workflows. These are the parts — take the ones you need, leave the rest on the shelf, and wire the ones you keep into whatever your team actually does.
Who does it, and who checks.
Any local CLI agent drops in here — Codex, Claude Code, Gemini. It takes a role, a task and a status you can read.
A second agent that checks the work against the brief and blocks the run until the checks pass.
What the agent can reach.
A real browser the agent can drive: click, type, read the DOM. The page is the input, not a screenshot.
Your own shell, in your own workspace. The agent runs the same commands you would.
Wire the project’s own suite into the run. The result is a gate, not a log line nobody reads.
The last block. It fires when every check above it has passed, and not a moment before.
How the run bends.
Route the run on what the agents report, so one canvas can carry two different outcomes.
Split the work across blocks that run at the same time, then join their results.
Send the work back until the check passes, with a bound so it cannot run forever.
Let the run split into two paths — one for the happy case, one for everything else.
Pause a step until something external says go — a webhook, a deploy, a human approval.
A canvas is only useful if the run behind it is trustworthy. These are the properties every DNP workflow inherits, whatever blocks you wired into it.
Every run in an isolated sandbox. Your keys stay with you, your code never leaves the machine.
Tasks that cannot complete are refunded automatically. No stuck jobs, no manual retries.
Bad patches and hallucinations are stopped by review agents before they reach your users.
New models and tools go live in days, some in hours — so your workflow never falls behind.
Cover token costs for your team, collect it all in a single invoice at month end.
Talk directly to the engineers running orchestration. No middlemen.
Each one is a wired canvas you can open, take apart and rebuild around the way your team works. They are the fastest way in — not the only way.
Real product experiences that stay on brand, in code, and ready to ship.

Start on one canvas for free. Move to Pro when you need more workspaces, and to Enterprise when the review process starts.
Two months free on yearly billing
A place to orchestrate, verify and ship.
$0forever
No card required
Included
Room for every agent on your team.
$9USD / month
$9 USD billed monthly
Included
Your infrastructure, your compliance rules.
Customannual agreement
Volume pricing and invoicing
Included
Straight answers on the product, the review loop, pricing and what is still being built.
DNP is in active developmentYes. The desktop app for macOS and Linux (x64) is available from the download link on this page. Windows is not available yet. DNP is in active development, so expect frequent updates.
Three agents slice a tangled store into verified reducers.
A workspace had grown around a handful of centralised singletons. Every new feature touched the same object, and nothing was safe to change without reading half the codebase. This pipeline maps the damage, cuts it into functional reducers, and proves that nothing broke.
Drag the nodes, zoom in, follow the arrows. This is the same workspace the agents ran in.
The state layer started as a convenience and ended as the bottleneck: every module imported the same singletons, and no tests covered the transitions between them.
The refactor shipped behind the same public API, so downstream modules never noticed — except that changes stopped being scary.
Claude CodeCodex CLI“Verified 48 spec assertions. Decoupled into pure reactive stores with zero memory leaks.”
Refactor · Verification
The Architect agent walks the import graph and proposes modular slices, writing the target contract before anyone touches code.
The Builder agent rewrites each singleton into functional reducers, preserving the public import surface exactly.
The Reviewer agent runs the headless regression suite — 48 assertions — and blocks the diff on any failure.
3 agents on one canvas, each with a single job.
Analyze dependency graph & propose modular slices.
Extract state machine slices & handlers.
Run headless Vitest suite & verify DOM.