Collect
Pulls together what the conversation knows: order, account, identity, intent. Every value typed, every source named.
Flows
The AI talks. Decision Engine decides.
Most platforms let the LLM decide how to execute your business processes. Flows don't. Decision Engine compiles every step into deterministic execution. The LLM handles only the language.
Trusted by operators running Flows at scale
2,000+ Flows running in production. 33 million flow-executions a month. Seven years of deployments at companies where getting it wrong isn’t an option.
The argument
The AI talks. Decision Engine decides.
Most platforms let the LLM decide how to execute your business processes. Flows don’t. Decision Engine compiles every step into deterministic execution. The LLM handles only the language.
01Observation
The LLM is good at language.
Understanding intent, balancing tone, keeping a thread coherent across a hundred edge cases. That work is probabilistic by nature, and the model handles it well.
02Observation
The LLM is bad at execution.
A model that's right 95% of the time isn't trustworthy at the architecture layer, where the same input has to produce the same output, audit trail, and downstream call - every time.
03Argument
Flows separate the two by design.
Decision Engine compiles your process into deterministic execution. The LLM stays in the conversation, where it earns its keep - phrasing the words, picking the tone, hearing the customer. The architecture handles the rest.
return_request.flowCompiled
- 01triggerintent = "return.request"
- 02callGET /orders/{{order_id}}
- 03branchdays_since_purchase < 30
- 04callPOST /refunds → #RF-{{id}}
- 05handoffqueue = returns-manual
“We knew we needed automation, but most AI platforms felt like black boxes. They charged per seat, limited access, and gave us no control over how AI actually worked.”
Mike Wu
Senior Director, Ecommerce and CX, Monos
The five primitives
One module. One job. Nothing left to chance.
Every Flow is a composition of five module types. Each does one thing, and one thing only - so the system is auditable end to end and behaves the same way every run.
Inputs · variables
Decide
Evaluates the rules and conditions you defined. Deterministic branching, not generated reasoning.
Action
Calls the right system: refund, escalate, restock, schedule. Real APIs, retried on real failures.
Message
Hands the LLM a context-bound mission and the response is grounded in the run, not improvised.
Transfer
Routes the conversation to a teammate with full context, the path executed, and the outstanding decision.
Decision Engine
Decision Engine.
The layer that compiles your business logic into deterministic execution.
Decision EngineZowie
01Compileflow → program
02Decidebranch · evaluate
03APIsystems · io
04Actionexecute · commit
Decision Engine
Compiled
Every Flow you publish becomes typed code. The canvas isn't a prompt - it's a spec.
Deterministic
Same inputs, same path, same outputs - every customer, every run, every replay.
Audited
Every step logged and traceable. Replay any run. Diff any version. Rollback in one click.
Bounded
The LLM is contained to language. It never crosses into the decision layer.
Build it visually
Design your process visually. It runs like code.
You design the process on the canvas. The compiled program is what runs in production.
flows / refund-eligibility · staging
TestDeploy
Start
Collectorder_id
Decideeligible == true
true
ActionIssue refund
MessageConfirm refund
false
MessageExplain ineligibility
TransferRoute to agent
Block · Decide
Refund eligible?Routes the Flow on a deterministic condition.
Conditionorder.eligible == true
Path A · True→ Action: Issue refund
Path B · False→ Message: Explain ineligibility
CompiledDeterministic - no LLM in path
What flows looks like in production
What Flows looks like in production.
The architecture that makes deterministic execution actually work at scale, every day, against systems that change.
Error handling.
Every external call has a retry policy, a timeout, and a typed fallback. When an upstream system fails, the flow doesn't guess - it follows the path you defined.
Versioning and rollback.
Every published version is preserved. Compare versions side by side. Roll back in one click. The same audit trail covers what changed and when.
Integration patterns.
REST, GraphQL, webhooks, sync vs. async, OAuth and signed requests. The same flow primitives compose against the systems your stack already runs on.
Observability.
Run logs, latency per step, error rate per branch, drift on the LLM responses. Every Flow shows what it ran, where it spent time, and what came back.
Compliance posture
Compliance-ready by architecture, not by guardrails.
Guardrails are output-side filters bolted onto a model that could say anything. Flows make the wrong path unreachable: the high-risk steps execute as compiled code, with typed inputs, named branches, and a per-step audit record.
There is no creative interpretation at audit time, because there was no creative interpretation at run time. Customers stay inside the policy you authored.
GDPR
EU AIACT
DORA
GDPR
EU AIACT
DORA
Where Flows lives
Flows live inside Agent Studio.
Agent Studio is the larger platform that deploys, monitors, and improves every Flow you build. Routing on the first turn, fallback decisions across the journey, and the feedback loop that closes the gap between what shipped and what runs — we built it the way we run it from this page.
See the full platform on Agent StudioYour business logic is too important to leave to probability.
Flows compile every step from front-line CX to risk and compliance, the LLM stays in the conversation, and you ship without infrastructure that can guess.