An email arrives. Somewhere, a model reads it and decides on a short sequence of steps: look something up, draft a reply, maybe file a ticket. It is a powerful idea and an uncomfortable one, because that plan did not exist a few seconds ago. Nobody reviewed it. Nobody agreed to it. It is exactly the kind of thing you should not simply run.
So we do not run it. The Verkko orchestrator can compose a plan at runtime, but the plan then goes through a compile step, and the compile step is the safety boundary. This is what it enforces.
A human gate before anything changes
The compiler inserts an approval step before the first step that changes something in the outside world. The orchestrator made the plan up, so it does not get to send an email or file a ticket on that basis. The approver sees the exact input the tool is about to be called with, not a summary of it, so they know what they are agreeing to.
Only the tools you have connected
The plan is restricted to the integrations that are actually connected for that user. A plan that reaches for a tool the user has not connected is rejected whole. It is never partially run, because a half-executed plan is harder to reason about than a refused one.
Missing information counts as a write
Every tool declares whether it has side effects. If a tool definition forgets to say, the compiler treats it as a write. An omission therefore costs an extra approval prompt, never an unapproved send. We chose which way to fail on purpose: a needless prompt is an annoyance, a surprise email to a customer is not.
One write per approval
A plan may contain at most one side-effecting step. Two writes behind a single approval is not what the user agreed to. The tools the run may call are then narrowed to exactly the ones the plan uses, and the finished plan has to pass the same validation as any hand-written workflow.
Most events produce no plan at all
Planning can legitimately conclude that there is nothing to do, and that is a normal answer rather than a failure. Most intercepted mail is receipts and newsletters. Starting a visible run for each one would teach people to ignore the orchestrator entirely, so it stays quiet unless something is worth acting on.
Where it deliberately leans the other way
Not every check fails closed, and it matters that you know which. The triage gate that decides whether an event deserves a planner call fails open: if it errors or returns something unparseable, the event goes to the planner anyway. That costs one extra model call. Failing closed would silently drop a customer's email, which is the worse mistake. Safety does not depend on that gate either way, because the plan still cannot touch the outside world without a human approving it.
It is off by default
Routing a live trigger through a plan composed at runtime replaces behaviour that customers already depend on, so it takes two deliberate switches: one global setting, and one flag on each automation, enabled one at a time. If anything is uncertain, such as no opt-in, no resolvable owner, no plan or an error, the event falls through to the existing path. An orchestrator that can break a working automation is not worth having.
Planning involves a model call, so it never blocks the system that delivered the event. The run is created on a background thread, and the event's own id becomes the run's idempotency key. If the mail provider redelivers a notification, it finds the existing run instead of starting a second one.
The principle
A model is allowed to propose. It is not allowed to decide. That split is the same one behind Approval is a feature: reads run freely, anything that changes the world waits for a person, and an unknown is treated as a risk instead of a pass. The compile step is where we make that true for plans nobody wrote by hand.
Curious how a run stays correct once a person finally clicks approve? Read Durable by design, or book a demo.