As-is: six manual steps, two decisions and two approval gates. You validate it first.
To-be: agents execute, controls supervise, humans keep the decisions.
HumansHybridAI agentsSystemsData & apps
The Agentic AI Process Designer
Eight ways in, one canvas out. An AI consultant maps how the work runs today for you to validate, then designs the version where agents do part of it, under controls, with a business case in your currency and a delivery plan.
🇪🇺 The first process design studio with EU AI Act, GDPR, NIS2, DORA and ISO 42001 advisors built in
Eight doors, one canvas
Every door ends in the same place: a faithful as-is you validate, then the agentic to-be, the advisors, the euros and the plan.
Plain words. The AI asks what is missing.
A blank canvas and 24 typed blocks.
A consultant asks. The brief writes itself.
Whiteboards and flowcharts read as evidence.
Up to 3 PDFs as one dossier. Every step cites its page.
Teams or Zoom, quoted speaker by speaker.
Any BPMN 2.0 file. No AI, no credits.
A CSV or XLSX of what happened, read in your browser.
The three newest doors
Most processes do not live in a tool. They live in a photo of a whiteboard, in a handbook nobody has read end to end, and in the meeting where someone finally explained how the work is really done. These three doors take that material as it is. Every screen below is the real studio, with a real sample.
Door four, photos
Drop up to three photos, 5 MB each: the whiteboard from a workshop, a flowchart from a slide, a page of a handbook. The AI reads them as evidence of how the work runs today and draws the as-is directly on the canvas, one block per step, in the lane of whoever does it. What the picture does not say stays out, and you validate the drawing before anything else happens.
Door five, documents
Load a PDF, or up to three as one dossier, 10 MB each and about 100 pages in total. The AI scans the dossier first and lists the processes it holds, each with its pages, the related material it found in annexes and the process it hands off to. You pick one. The as-is is then drawn with a page reference on every step, and where two documents disagree, the contradiction is declared rather than hidden.
Door six, meeting transcripts
Bring the Teams or Zoom transcript of a discovery meeting as .vtt, .srt or .txt, up to four hours or forty thousand words. The audio is never uploaded, only the text. The AI screens the meeting for the processes discussed and where in the conversation each one lives, by minute. You pick one and the as-is is drawn from what people actually said, quoted speaker by speaker, with the minute as provenance on every step.
Built for the room where the decision happens.
Workshops, steering meetings, pitches: the canvas reads from the back of the room.
The interview room
No blank page. The discovery consultant asks short, concrete questions and mirrors the process back while the brief board fills in live: steps, volumes, systems, constraints. Every field stays editable by hand, the session can pause and resume, and one click generates the design from the board.
Prefer writing? The Describe door reads your text and, when key facts are missing, asks two to four targeted questions before designing. Details in AI process mapping.
Micro-task blueprints
Select any to-be step and the AI writes its operating procedure grounded in the step's real context: the systems it touches, the steps that feed it, the controls that supervise it. Four phases, always: setup, execution flow, exceptions, handoff, concrete enough that the implementation team can build from the list alone.
Copy it as text, ship it in the PDF annex, or send the setup phase straight to the delivery board. More in the AI SOP generator.
Build kit
Every agent, gate and decision on the to-be becomes a node. Export an n8n workflow you import as is, with each agent's prompt composed from the design, or a LangGraph Python scaffold with a node per block and an interrupt wherever a person has to answer. Both carry the boundaries, controls and escalation you drew.
{
"name": "Supplier invoice processing",
"nodes": [
{ "name": "⚡ Invoice lands in AP inbox",
"type": "n8n-nodes-base.manualTrigger" },
{ "name": "🤖 Intake agent extracts and validates invoice data",
"type": "@n8n/n8n-nodes-langchain.agent", "typeVersion": 2.2,
"parameters": { "options": { "systemMessage":
"You are the \"Intake agent\" in \"Supplier invoice
processing\". Systems you touch: Outlook, NetSuite.
Never create a new supplier record and never change
bank details. Post as draft only, with a confidence
score per field; below 0.9 route to human review…" } } },
{ "name": "🤖 Duplicate and anomaly screening", "type": "…agent" },
{ "name": "❓ Clean match?", "type": "n8n-nodes-base.switch" },
{ "name": "🚦 Approval gate: manager above 500, CFO above 10000",
"type": "n8n-nodes-base.wait",
"parameters": { "resume": "webhook" } },
{ "name": "🏁 Invoice paid on time, fully traceable", "type": "…noOp" },
{ "name": "Chat model", "type": "…lmChatOpenAi" }
],
"connections": { "⚡ Invoice lands in AP inbox": { "main": [[
{ "node": "🤖 Intake agent extracts and validates invoice data" } ]] }, … }
}A real import: agent nodes with the system message written from the step, a switch for the decision, a wait node for the approval gate, one chat model wired to every agent.
class State(TypedDict, total=False):
data: Annotated[dict[str, Any], _merge] # the case
decisions: Annotated[dict[str, str], _merge] # gates and routes
log: Annotated[list[str], operator.add] # the path taken
def n_intake_agent_extracts_and_validates_invo(state: State) -> dict:
return call_agent("n_intake_agent_extracts_and_validates_invo", state)
def n_approval_gate_manager_above_500_cfo_abov(state: State) -> dict:
answer = interrupt({"gate": "Approval gate: manager above 500, CFO above 10000",
"rule": "Single approval point with the agent evidence pack…",
"case": state.get("data", {})})
return {"decisions": {"approval_gate": answer}}
graph = StateGraph(State)
graph.add_node("n_intake_agent_extracts_and_validates_invo", …)
graph.add_node("n_duplicate_and_anomaly_screening", …)
graph.add_node("n_automated_three_way_match_with_tolerance", …)
graph.add_edge(START, "n_invoice_lands_in_ap_inbox")
graph.add_conditional_edges("n_clean_match", route_n_clean_match, {
"clean, within tolerance": "n_post_and_schedule_in_the_payment_run",
"missing PO": "n_exception_agent_chases_po_owner_and_supp",
"variance above 500": "n_approval_gate_manager_above_500_cfo_abov"})
graph.add_edge("n_invoice_paid_on_time_fully_traceable", END)
app = graph.compile(checkpointer=InMemorySaver())One node per block, merged state across parallel branches, interrupt() where a person decides, conditional edges from the arrows of the design. Runs end to end as a skeleton.
Generated from the supplier invoice starter and validated by a real n8n import and a LangGraph run. More automation targets are on the way. How agentic workflows are designed here.
Project control
Blueprints, quick wins and governance findings become tasks on a kanban with owners, due dates and a dated follow-up log. Overdue work turns red. A project control view shows every process's rollout at a glance, and the executive PDF ships with the implementation plan grouped by step.
The full loop, from a described process to a tracked delivery, in business process redesign.
One process, one team, three time zones.
The design travels: share it, comment on it, and keep every version, wherever your people are.
Work together, anywhere
A redesign only survives if the people who run the process recognise themselves in it. So the design never stays locked on one laptop: it moves to whoever needs to see it, react to it, or approve it, on any device, anywhere in the world.
Preventive, detective and corrective controls supervise your agents. Human gates guard the decisions that must stay human. A governance check reads the whole design against engineering rules, model-structure rules from published research and the European advisors, and proposes one-click fixes.
Human hours saved versus real AI running costs, computed from live model prices. Implementation sized per agent, payback month and 12-month ROI, and an executive narrative written on top of your numbers, never instead of them.
Every step breaks into a build-ready blueprint: setup, execution flow, exceptions, handoff. Send them to a delivery board with owners, due dates and follow-ups, and export the whole thing as an executive PDF.
Built-in advisors read your design against the EU AI Act, GDPR (data minimisation on every hand-over; Art. 22, no solely automated decisions about people) (prohibited-practice signals, Annex III high-risk candidates, a readiness annex in the PDF), NIS2 (essential-entity sectors must show the incident path: 24h/72h/1 month) and DORA (financial entities: ICT third-party register for cloud models, 4h/72h incident clocks), plus an ISO 42001 quality lens scoring every agent on owner, impact, data, verification and disclosure. Heuristic signals with the article cited, never legal advice.
What-if sliders scale the volumes, squeeze the human capacity or triple the AI prices, and the whole case recomputes: net, payback, backlog warnings, and the month the redesign breaks even, drawn on a 12-month curve.
Import any BPMN 2.0 file from Signavio, Camunda, Bizagi or draw.io as a faithful as-is, with no AI and no credits; export BPMN 2.0 back. For whoever builds the agents: an n8n workflow you import as is and a LangGraph Python scaffold, both carrying each agent's instructions, controls and human gates, with more automation targets on the way; plus agent specs in markdown, a PPTX deck for the steering meeting, and PDF, PNG and JSON. Your design is never locked in.
Who it is for
Consultants running AI transformation workshops. Operations leaders who need to answer "which steps should an agent do" with more than a gut feeling. Teams that want the map, the guardrails and the numbers before they build anything.
Start with AI process mapping if you are documenting today's reality, compare us with classic process mapping software, learn how agentic workflows actually work, or go straight to business process redesign.
The studio is in private preview. Open it to request access, or walk through a real, read-only example first.