When an AI workflow runs, you should be able to say exactly what was approved: which version, which apps it may change, and whose access each call uses. Dittoly makes a person approve that exact version, names every identity before the first run, and needs a new approval for any edit.
I built Dittoly because every AI automation demo I sat through ended the same way. An agent with 14 tools merged the right branches on stage, and someone asked to point it at production by Friday.
Nobody in that room could say what they would be approving. A prompt, a tool list and a service account do not describe what will happen on Tuesday. Dittoly is open source under Apache 2.0: the project site gives the short tour, and the code is on GitHub.
What a reviewer actually signs
You describe the process in plain language. The AI shows its whole plan first, asks every question it needs in 1 numbered list of at most 10, writes down what it assumed, and drafts a Flow: fixed steps that call approved modules, each pinned to a version.
The review page does not open on the steps. It opens on 1 row per capability, built from the same manifests the runtime enforces.
| The review shows | What it answers |
|---|---|
| The apps it talks to | Which hosts this version can reach |
| What it changes out there | Every action marked as a write, step by step |
| Whose access each call runs with | The runner's own, a team's shared account, or a teammate's for 1 step |
| What it does on this machine | Builds, tests or code it runs in a sandbox |
| The frozen version | Which version is approved, and its hash |
| Runtime restrictions | Undeclared hosts or credentials, another team's data, state of its own, changing itself without a new approval |
What approval protects, precisely. Approval binds the Flow definition and the content of every module version it pins, and database triggers reject changes to those versioned rows. A run starts only from an approved version, and any edit through the product creates a new pending version that needs its own approval.
That guarantee assumes the server, its database and its master key are in trusted hands. Someone with direct database or host access can change rows, and the sealed audit log only exposes that if you keep its latest hash somewhere they cannot reach.
One Flow, from request to posted comments
Here is a complete pass with the pull-request review Flow from the repo's test fixtures. The request is "review this pull request and post comments, skipping points already made".
- Draft. 4 steps: read the pull request, list the comments already on it, an AI step that writes the review, and a step that posts it. The 3 GitHub steps pin
github-review@1.0.0. - Review. The rows say it talks to the GitHub API host, changes 1 thing (
post_review_comments), and runs with the runner's own GitHub token. The review also flags 1 open path: text the AI wrote reaches a write step. - Approve. An approver approves version 1, and its hash is recorded. On a shared server the author cannot approve their own Flow.
- Run. A team member pastes a pull request URL, which makes them the runner. The 2 read steps run with the runner's token, and the AI step drafts the comments.
- Sign-off. Because the AI wrote the review, the post step waits and shows its exact values: the repo, the pull request number, the commit and every comment. The decision is bound to a hash of those values, and an approver can give it from the portal or a paired phone.
- Post. The step runs with the runner's token. Before posting, the module lists the comments already on the pull request and skips any on the same file and line whose text matches, ignoring case, punctuation and spacing, or where one wording contains the other.
That check is what makes a retry safe after a lost answer: the second attempt finds the comments the first one posted. It has 2 limits worth knowing. A genuinely new remark that repeats an existing one on the same line is skipped too, and 2 runs posting to the same pull request at the same moment could both post, because each lists the comments before the other has written.
If the runner had no GitHub token, the run would not take a shared one. They would ask a teammate who has access to run that 1 step, which is the third identity below.
Three identities, named before the run
Every call runs as 1 of 3 identities, and the review's access row says which 1 for each step. Nothing runs as a hidden service account.
| Identity | When it is used |
|---|---|
| The runner's own access | The default: the token the person who started the run keeps in their personal vault |
| A team's shared account | Only where a team admin stored a team credential and the Flow's step is set to use it |
| A teammate, for 1 step | When the runner lacks access to 1 app and asks someone who has it; the step's inputs are frozen and hashed before the teammate decides, and both names are recorded |
Sharing a Flow never shares a token. A delegated teammate signs off 1 action with known values, not the whole Flow, and an organization rule can forbid delegation entirely.
The manifest as the contract
Modules are generated in chat, but the part I care about is the manifest beside the code. Here is the GitHub fix module from the test fixtures, trimmed to the action that opens a draft pull request.
{ "name": "github-fix", "version": "1.1.0", "settings": [ { "id": "host", "type": "host", "default": "api.github.com" } ], "hosts": ["{{settings.host}}"], "credentials": [ { "id": "github_token", "label": "GitHub token (fine-grained: Contents and Pull requests read and write)", "hosts": ["{{settings.host}}"], "placement": { "type": "bearer" } } ], "actions": [ { "name": "create_draft_pr", "effect": "write", "idempotent": true, "credentials": ["github_token"], "undo": { "action": "close_pr", "input": { "repo": "{{ input.repo }}", "number": "{{ output.number }}" } } } ] } The module has no network of its own. Every request goes through a broker outside its code, which allows only the declared host and attaches the token, so the module never holds it.
What idempotent does and does not do. The flag is a promise the module makes and a reviewer checks; the engine cannot enforce it alone. It only changes what the engine does when an answer is lost: an idempotent write is repeated, and any other write stops with uncertain_outcome and is never repeated blindly.
The promise is kept in the module's code. GitHub refuses a second open pull request for the same branch, so when create_draft_pr gets that refusal it looks up the open pull request and returns it instead.
Inside Dittoly, 1 worker owns a step at a time. Each run's work is a leased job with its own claim token, and a worker whose lease expired can no longer record a result or touch the job.
That ownership ends at Dittoly's edge. A stalled worker may already have sent a request that reaches the app after another worker has taken over, which is exactly why a write that is not idempotent stops with uncertain_outcome instead of being retried.
The undo block names how to take the change back: close_pr, built from the call's own input and output. An approver signs off before any reversal runs, inside a 7-day window by default.
Untrusted text is traced, not judged
Dittoly never asks a model whether some text looks hostile. It traces every path from untrusted text to a step that changes data, from the approved definition alone, so the same Flow always gets the same answer.
Text a model wrote waits for a sign-off wherever it lands, as the post step did in the example. Text from an app or a webhook, like a ticket description, waits only where it would choose the destination, such as a channel or recipient, or something to execute.
An approver can accept a specific path in advance with a written reason of at least 10 characters, and that acceptance is audited. A sign-off is bound to a hash of the values it showed, so changed values ask again.
What the approval does not freeze: the model
The frozen version covers the definition and the module code. It does not cover which AI model answers its AI steps, and I would rather say that plainly than let "frozen" imply it.
By default a Flow follows the organization's model, and a runner can pick a model for a single run. An approver can lock a version to 1 model: a selection that blocks those runner overrides but still allows the fallback to the organization's model described next.
If the chosen or locked model is no longer available, the step does not stop. It falls back to the organization's model, says so in the run commentary, and notifies the team's approvers.
That trade favors finishing the run over pausing it. An AI step's answer still meets the same downstream checks, so a fallback model's text that reaches a write step waits for a sign-off like any other model's text, unless an approver accepted that path in advance.
To judge a model before relying on it, npm run bench:ai scores its drafts with Dittoly's own checks, and npm run bench:tasks checks whether those drafts do the job. Every version an AI writes records the provider and model that actually answered.
Where the boundaries are, and what they rest on
Dittoly has 2 sandbox backends, and they make different promises. The difference matters most on a laptop.
| Backend | Used by | What enforces the boundary |
|---|---|---|
| Docker or Podman | Required in shared mode; startup refuses anything else | A container per call with no network, a read-only filesystem, all capabilities dropped, a non-root user, and memory and process limits |
| Process | The default for a local, single-person install | Node's permission model: no network, reads only the module's own folder, no code built from strings, an empty environment |
The Node.js permission model documentation is explicit that "This feature does not protect against malicious code." Dittoly's own code agrees, which is why shared mode refuses to start without the container backend.
So the "Runtime restrictions" row is enforced by containers and the broker on a shared server. On a local install it guards against mistakes in modules you approved yourself, not against a hostile module.
Build and fix steps that run a project's code always use containers, each on its own internal network whose only exit is a proxy that refuses private addresses. The Dittoly server itself controls the container engine, so it belongs on a host dedicated to it.
Five commands to a first run
A local install needs Node.js 26 and Docker with Compose for PostgreSQL and RabbitMQ. Node 22 will not do, because the process sandbox needs a Node.js version whose permission model can deny network access.
git clone https://github.com/SudoDevStudio/dittoly dittoly && cd dittoly npm ci npm run setup:local npm run services:up npm run build && npm start Open the sign-in link it prints and you are the admin. For a team, use the Docker Compose path with DITTOLY_MODE=shared, single sign-on and the container sandbox, on Docker Engine 28 or later with at least 2 vCPU and 4 GB.
The Dittoly site has a get-started section and the guides. Approve your first Flow, read its rows, and tell me which one surprised you.
FAQ
Where does my data go?
Only to destinations someone configured or approved. That means the AI provider an admin chose, the hosts each approved module declares, the pages an approved browse step opens, and chat apps or notification channels a team connects.
It also covers audit streams and a git repository an admin sets up. 1 more: the home chat's microphone uses the browser's speech recognition, and Chrome sends that audio to Google.
What happens to an approval when someone edits the Flow?
It ends. The edit becomes a new pending version, and until someone approves it the Flow has no approved version to run. The review of the new version lists what changed step by step.
Can I approve from my phone?
Yes. Pair a phone by QR code, with no app to install, and approve or reject waiting sign-offs by voice or by tapping. The phone session cannot see credentials or change Flows, and Telegram and WhatsApp can act as the same command channel.
Meta glasses can serve as the phone's Bluetooth headset. The heads-up layout for Ray-Ban Display glasses has not yet been tried on real hardware.
Can an AI assistant approve its own Flow?
No. An assistant connected over MCP can run Flows that were offered to it, as you, and save new drafts. It cannot approve anything, change an approved Flow, or see stored keys.
Can I use a model I run myself?
Yes. Set DITTOLY_AI_PROVIDER=ollama with your model and run npm run bench:ai first. A Flow with no AI step needs no model at run time at all.

