Netcall Liberty AI 01 / 05 Can I trust the process the AI just wrote?
A seamless handoff from conversation to process creation.
— view full size The assistant says up front that specific areas can be changed by asking. A generated process you can only accept or bin is a process nobody edits.
Every role the process touches is written out as its own card. Work gets routed to these names, so they are the first thing worth checking.
Asked to rename a role, the assistant answers with a preview: what it would alter, section by section, while the blueprint on the right still says the old thing.
Apply is a separate, deliberate act by the person reading. Until it is pressed, the preview is the only thing that has changed.
The Blueprint Generator, as designed. The assistant's proposed change sits in the thread on the left; the blueprint it would alter sits on the right, still unchanged. Hover the markers.
A sentence in. A working business process out. Nobody wanted the middle to be invisible.
Liberty AI is Netcall's process-mapping product. The AI Builder was meant to take a plain-English description and hand back a structured process — the steps, the people who carry them, the sign-off that closes them. The design question was never how to generate it. It was what a person is shown between asking and it being real.
A Blank Canvas Is Expensive
Mapping a process by hand means naming every step, every role and every hand-off before you have anything to react to. Correcting a draft is a smaller job than writing one. That is the whole case for generating it.
A Process Is Not A Document
A generated summary is harmless until someone reads it. A generated process assigns tasks to named people and decides who can close the job. It has consequences from the moment it is live.
A Wrong Step Is Only Cheap Early
Caught in a preview, a mis-assigned approver is one click. Caught after the process is running, it is a policy problem with somebody’s work stuck behind it. So the review has to sit before apply.
“Nothing the assistant writes reaches a live workflow until someone has seen exactly what would change.”
Ask, Clarify,
Generate, Review,
Decline
Five turns, and the interesting one is the last. The first four are the assistant doing what it was asked. The fifth is it not doing what it was asked, and saying why.
The column below is the whole thing on one screen. It is drawn the way Liberty AI draws a generated process — because that is what this is, and because the product leaves one slot on every step deliberately empty.
- 01
Ask
The person
One sentence. The assistant has an intent, not a process, and says so before it asks for anything.
- 02
Clarify
Liberty AI
Two closed questions. A clarification you have to compose yourself is one most people skip, and a skipped clarification comes back as a wrong process.
- 03
Generate
Liberty AI
Named stages rather than a spinner, so the wait shows what is being decided — including the answer you just gave, read back.
- 04
Review
The person
The proposed change against what it would replace. Ask for another and the loop runs again rather than starting over.
If the change would remove the last approval in the process
!Decline
Liberty AI
Names the one thing at risk and offers two ways through. A refusal with no route out is a wall, and the next thing the person does is go round it.
- 05
Apply
The person
One Request,
Start To Finish
Each panel rebuilds one state of the prototype, in the order the prototype runs them — so you can read the sequence here and then go and click the real thing further down.
Nothing exists yet. The assistant has an intent, not a process, and it says so before it asks for anything.
Two questions, both closed. A clarification you have to compose yourself is a clarification most people skip, and a skipped clarification comes back as a wrong process.
- 1Reading your answers Done
- 2Laying out the steps Done
- 3Adding the sign-off Now
A spinner says wait. Named stages say what is being decided while you wait — and the third one is the answer you gave, read back to you before the process arrives.
- 1Collect starter details
- 2Set up IT accounts
- 3Assign a workplace buddy
- 4Manager sign-off Approval
- 5Mark onboarding complete
Applying does not end it. The confirmation carries an Undo that stays in the thread rather than a toast that times out, so the way back is still there a minute later.
It refuses, names the one thing that is at risk, and leaves two ways forward. A refusal with no route out is just a wall, and the next thing the person does is go round it.
One sentence in — and the assistant does not start building yet.
A simplified HTML rebuild of the prototype, for reading. The working version is embedded further down this page.
A diff has to be announced, not just coloured
Struck-through for removed and tinted for added is the whole story only if you can see it. In the prototype the proposal card is a focus target: when it appears, focus moves to it, and a polite live region says that a proposed change is ready to apply or discard. The sentence carries the same information the colour does.
Apply and Discard are real buttons, adjacent in tab order, and applying announces the result and puts an Undo in the thread. A toast that expires is the usual pattern here; it fails a screen-reader user and a distracted one for the same reason.
None of that has been through an audit. It is designed intent, built into the prototype — the contrast of the edited-state tint and the behaviour under a real screen reader are both still to be checked.
Reviewable,
Not Autonomous
The faster the assistant feels, the less the reader sees. Every moment I put between asking and done — a clarifying question, a named progress stage, a preview — buys understanding with time. There is no version of this where both go up.
So I spent the budget on the last gap, between generated and live. A slow clarify step is annoying. A process that quietly routes approvals to the wrong person is a call from somebody's manager. The assistant is allowed to feel deliberate at the start; it is not allowed to be silent at the end.
Apply As It Generates
Each section could have been written into the live process as it resolved. That is the faster-feeling build, and it deletes the one moment where a wrong approver is cheap to fix. Not doing it costs a click between a correct generation and a saved one, every single time.
One Free-Text Box
Describe the process, let the model infer the rest, ask nothing. It reads as more capable and it is genuinely quicker for someone who already knows what they want. The two questions slow that person down to protect the one who has never mapped a process and cannot tell what they left out.
A Separate AI Mode
A dedicated AI page is easier to build, easier to explain, and keeps generated output well away from anything live. It also makes the assistant somewhere you go rather than something you ask, and the process you want to change is never in that somewhere. Keeping it in the workspace cost a harder layout and a standing argument about how much width the panel gets.
What Staying In The Workspace Looks Like
The panel docks beside whatever is already open and names the part of the workspace it can see, so the first thing it tells you is the limit of what it knows. Ask it to build something and it does not take the page over: it hands you to the generator with the request carried across, and the thing you were looking at is still there when you come back.
— view full size 
— view full size Where Trust Is Actually Won
Nobody's confidence in a generated process is decided on the screen where everything worked. It is decided on the one where it didn't, and the product still told them what to do next.
— view full size 
— view full size One Assistant,
Six Surfaces
Liberty AI is not a chat box bolted to a home page. Everything above had to hold up in a workspace full of live processes, in two different generators, in the comparator, in the map editor and on a role's own page — and every one of those has a different idea of what “the thing you are looking at” means.
Twelve screens from the design file, in roughly the order someone meets them. None are production captures, and a few labels in them are still unfilled.
12 screens — scroll the strip, or use the arrow keys.
Click Through It Yourself
It plays itself through once, then hands you the controls. Answer the two questions, open the editor, watch it generate, then ask for a change and apply or discard it. Then press “Skip the sign-off” and watch it refuse.
De-branded for confidentiality — the product is “Flowbase” and the assistant is “Atlas AI”. It is scripted rather than a live model: the replies are written, the timings are fixed, and it only answers the paths I built. Everything it does here is a design decision, not a capability claim.
Plays as a short walkthrough when it scrolls into view — pause, or just click into it to take over. With reduced motion on it waits to be started.
There is no usage data behind this page. It is a prototype and a design file, so everything below is a question I would want instrumented, not a result I can report.
What I’d measure next
Nothing here has been measured. These are the five I would instrument first, and the point of most of them is to find out whether review-before-apply survives contact with people in a hurry.
Applied against discarded
On proposed changes. A discard is the review doing its job, not the assistant failing — so this is a health check, not a score.
Undo rate, and how late
An undo minutes after apply means the preview did not show the thing that actually mattered.
Refinement turns before stopping
And whether they stopped because it was right or because they gave up. Those look identical in the data and opposite to the user.
Generated, edited, published
Drop-off between the three. The gap that matters is the last one: a process nobody publishes changed nothing.
First sentence to publishable
The whole promise is that this is faster than building it by hand. That claim needs a number behind it.