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.
2,000+
Flows running in production
33 million
Flow-executions a month
7 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.
Customer
Can I return this if the wheels are scuffed?
Language layer
Return intent, soft tone, policy question.
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.
inputorder_421
branchreturn_window
outputmanual_review
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.
LLM
Tone, phrasing, intent.
Engine
- triggerintent = "return.request"
- callGET /orders/{{order_id}}
- branchdays_since_purchase < 30
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.
“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
Business logic that runs the same way every time
The layer that compiles your business logic into deterministic execution.
Compiled run
Same inputs. Same path. Same result.
Triggerreturn.request
Policydays_since_purchase < 30
ActionPOST /refunds
Fallbackreturns-manual
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.
Start
Collect
Decide
true
Action
Message
false
Message
Transfer
Refund eligible?Routes the Flow on a deterministic condition.
Conditionorder.eligible == true
Path AAction: Issue refund
Path BMessage: Explain ineligibility
CompiledDeterministic - no LLM in path
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
Compliance-ready by architecture, not by guardrails
Guardrails are output-side filters. Flows put compliance into the program itself: typed inputs, deterministic branches, permissioned actions, and a per-step audit record. There is no creative interpretation at audit time because the system can show exactly what path ran, what data it used, what it called, and what it returned.
GDPR
EU AIACT
DORA
GDPR
EU AIACT
DORA
Your 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.