Boxes and arrows on a canvas. It does exactly what you wired — including the parts you got wrong, and nothing tells you which those are.
Describe the outcome. Approve the contract. Everything just hums.
Describe the result you want. You get back a contract in plain words — which accounts it touches, what it must never do, what happens when it breaks. Approve that, and only then is any code written.
Set up your first proven automation in about a minute.
Agreed before builtNothing is generated until you approve what it will do.
Proof before accessCredentials are released only after the suite passes.
Mocked, never liveProviders stay untouched while an automation proves itself.
Every result shownFailures included, in full, never summarised away.
The problem
Right now you get two bad choices
Wire up every step yourself and hope you thought of everything. Or let an AI loose on your accounts and read about it afterwards.
An agent picks its own steps as it goes. Fast, until the morning it picks one you would never have agreed to.
Both hand over your live accounts before there is any evidence. The first honest test is production, and the person who tells you is a customer.
How it works
Four steps, in this order, every time
The order is the point. Nothing gets access until the step before it has produced evidence.
- Describe the outcome
Say what should be true when it works — “every qualified lead reaches the right rep in under a minute”. No node graphs, no trigger pickers.
- Approve the contract
You get back a plain-language contract: what starts it, what it may touch, what it must never do, and what counts as success. You approve it, and it is frozen.
- The AI writes the automation
A model writes the program from the approved contract — the code that talks to your systems, not a chain of prefabricated nodes. Change the contract and you get a different, traceable version.
- It proves itself before it connects
The model writes tests for what it built — happy path, duplicates, missing data, timeouts — and runs them before any credential exists. You read the results and decide.
What you approve
The agreement is the product
A contract, not a diagram
Every automation has an approved, versioned specification. Change it and the old version stays intact, so you can always see what you agreed to and when.
Nothing changes behind your back
Approved versions are immutable. A new build is a new version with a visible diff, so an automation cannot quietly drift away from its contract.
Before it connects
Nothing is given a key on trust
Proof before access
The generated code is tested before anything connects: every provider response mocked, no credential in the building, and the result shown to you in full. An automation that cannot pass its own tests does not get keys.
Credentials never touch the build
Secrets go to an isolated encrypted surface. They never appear in chat, generated code, logs, or evidence — the system refuses them if you try.
The difference
Every run can answer “why did you do that?”
A run is not a log line. It records the exact contract version it ran under, the assertions it had to satisfy, and the proof it produced — stored at the time, not reconstructed later. When someone asks what your automation was allowed to do six months ago, you can show them.
Contract version linked to every run Assertions stored with their results Immutable, exportable history
Once it is live
It keeps its own house in order
Repairs stay in bounds
When a scenario fails, the fix is scoped to the failing piece and the whole suite reruns. Nothing silently rewrites your approved behavior.
Evidence you can hand to audit
Every run stores the contract and program version it ran under, what it expected, and what happened. Stored at the time, so it holds up months later.
Pricing
Start free. Pay when it runs your business.
Runs are never counted. Every plan meters the two things that cost money to produce — automations built, and the time they spend running.
Free
Build a few automations and prove them end to end.
$0forever
No card requiredStart free- 2 live automations
- Runs every 15 minutes, 10s each
- Full contract and version history
Solo
For one person running real work against real systems.
$24per month
$290 billed once a yearChoose Solo- 10 live automations
- Runs every 5 minutes, 15s each
Business
For a team that has to answer to someone.
$83per month
$990 billed once a yearChoose Business- 40 live automations
- Runs every 1 minute, 30s each
Scale
For teams who have to answer to security and audit.
$249per month
$2,990 billed once a yearChoose Scale- Unlimited live automations
- Runs every 1 minute, 60s each
- Priority runner
Enterprise Coming soon — Private deployment, SLAs, enterprise onboarding and a contact-sales workflow are not implemented yet.
Join previewPrivate deployment, custom evidence retention, security review, SLA and onboarding support.
Questions
The things people ask first
How is this different from Zapier, Make or n8n?
Those tools help you build a workflow. Whether it does the right thing is left to you, and you connect your live accounts before there is any evidence either way. Here you read what it will do and approve it first, in plain words. The code is generated from what you approved, and it has to pass a scenario suite before it is given a single credential.
How is this different from an AI agent?
An agent decides its own steps while it runs, so the only way to know what it did is to read the log afterwards. Here the decisions are settled before anything runs, in a contract you approved. The program that comes out cannot contact a company you did not agree to — not by policy, but because the gateway will not route it.
What actually happens when something goes wrong?
The run stops and records why. It does not half-finish and leave your CRM in a strange state. Duplicate deliveries, missing fields, provider timeouts and rate limits are all scenarios the build has to survive before it ships, and each run keeps the trace of what it did.
Do you ever see our credentials?
No. Credentials go to a separate encrypted surface and are never placed into chat, generated code, logs or evidence. The system actively rejects anything secret-shaped in a contract, so a key cannot be pasted into a spec by accident.
What counts as a run?
One execution of one automation, whether it is a proof run against scenarios or a live run. Proof runs are unlimited on every plan — we would rather you tested more, not less.
Can I use this in production today?
Yes. Building, testing, connections and unattended scheduled runs are all live today. Every automation runs from a contract you approved, inside an isolated runner behind a capability gateway, with evidence stored for every run — and you can switch anything off instantly, from the same switch that turned it on.
Everything just hums.
Build one automation and watch it prove itself. It takes about a minute, and you will have real evidence at the end of it — not a demo.
Start free — no card needed